That was my first thought: I've seen these projects before — they're where you find 5 slightly different implementations of similar logic, no logging or tests, failures as soon as someone uses Unicode, etc. and I get an order of magnitude performance improvement by replacing that code with an external module which has had the other 19 afternoons' worth of work it actually takes.
Not diminishing the article at all, there's massive value I've gained from leveraging this runtime solution in multiple projects: https://github.com/antonmedv/expr
The language is easy enough for people to pick-up.
It's a fun thing to do and it gives you a lot of insight into what is efficient to implement in a programming language that you don't get by simply using someone else's language.
Well even if it just gave you some reasonable abstraction over regex, at this kind of scale it seems useful. Plus I bet they had excellent test coverage, which really makes refactoring much easier.
It is surprisingly helpful on old legacy projects with multiple contributors. It will imitate their code style and variable naming, even if outdated or poorly constructed. Saves time looking through spaghetti code to figure out why some function wasn't abstracted or named in a consistent way.
I used it as a workout for the compiler that I'm writing. I solved every problem in my own language, so that was pretty cool. The language is now almost as powerful as C. I kept all the code in one file, which now has grown to 4500 LoC (non-empty, non-comment), producing 38k LoC in LLVM.
On day 6 I got a stack overflow, so I had to quickly implement new/delete. For the Elf processor I had to add in binary operators. Design-wise it taught me that good literals can be really helpful, e. g. an initializer expression for an array of structs. With Python's dict/tuple/array literals e. g. you could sometimes replace parsing entirely with a couple text transformations in Sublime. Maybe this is specific to these kinds of problems, but I think it would also be helpful for unit tests.
It was fun to learn a new algorithm (A*) and implement it. Day 23 part 2 was my favorite. I was stuck for hours, tried two solutions that didn't work out. Went to bed frustrated, then implemented the solution the next morning. I'm still thinking about it, it's an interesting problem.
Definitely. I also think there is a lot of skill in knowing that something should already exist. I've seen a lot of really bad code which just more convolutedly implements something that exists in the standard library or is an easy download.
Sure, it's definitely a hack on top of the language, but sometimes you don't have the option to rewrite and those tools can make your code more functional without having to switch stacks. It's not perfect, it's just a bit better than the alternative in many cases.
it's not as bad as I thought - I thought it would make random changes to your code to try to get it to run, which is what actual sloppy programming languages feel like.
Eh, it wasn’t the best, but it was still better than any other language’s equivalent except for Rust’s. In any case, modules have worked wonderfully for me so far.
This is about as useful as that Ruby interpreter written in JavaScript. Without the libraries that help make a language good it's nothing but a neat trick.
I honestly think this is solving a real problem with commonly used languages and their lack of syntax abstraction and expressiveness.
Do you think there's a risk that a tool like this could lead to an explosion of the size of codebases written in these languages? It's great that programmers can be freed from the need to write boilerplate but I fear that burden will shift to the need to read it.
I've used it for performance boosts. It's not perfect, but if I paste a method (my own code) and say 'rewrite in fewer lines' to simplify, or 'rewrite to run faster', I've been in awe at what it comes up with that hadn't occured to me. Tricks in python I wasn't aware of, or hadn't considered using a different datastructure that can be searched faster (for some reason my brain always defaults to lists, when a set may be better, for example).
It absolutely makes errors though, so unit tests are critical, but I've got code running so much faster as a result.
reply