Mike Hadlow

op's article could've been plucked from 2012 - this is one of my favorite rest rants from 2012: https://mikehadlow.blogspot.com/2012/08/rest-epic-semantic-fail.html ..that was written before swagger/openAPI was a thing. now there's a real spec with real adoption and real tools and folks can let the whole rest-epic-semantic-fail be an early chapter of web devs doing what they do (like pointing at remotely relevant academic paper to justify what they're doing at work)

I've been following eww's development on the sidelines for a while. I wondered if you considered making it callable as a library, for some scripting language (e.g. python or lua or something), rather than growing your own bespoke language? To me it seems you risk people demanding more and more features in the "configuration language", and it turns into a (bad) fully Turing complete programming language before you notice. Like in the configuration complexity clock[1]. [1] http://mikehadlow.blogspot.com/2012/05/configuration-complexity-clock.…

Being skilled in Lisp or other DSL producers can be amazing for one-man projects. Above that sticking with standard languages really is useful. I remember seeing a "DSL cycle" somewhere - http://mikehadlow.blogspot.com/2012/05/configuration-complexity-clock.…

Classic Lava-layer development anti-pattern http://mikehadlow.blogspot.com/2014/12/the-lava-layer-anti-pattern.htm…

This reminds me of a great post about the typical software evolution going from hard coded values, through configuration and rules engines to a DSL, only to be back where you started. I have seen it happen on multiple projects, it’s hard to spot it at the time as all the changes seem sensible but hindsight is a wonderful thing http://mikehadlow.blogspot.com/2012/05/configuration-complexity-clock.…

I was with you up until your last sentence. pip and virtualenv are hacky kludges that grew legs and lungs, that's how old python's issues around deployment are, there's an era before pip and virtualenv. There should be an abstraction for it (deployment, versions, import hacking) like what pathlib did for file path manipulation. We have a classic lava-flow pattern. http://mikehadlow.blogspot.com/2014/12/the-lava-layer-anti-pattern.htm…

SEEKING WORK | .NET / C# developer | Remote: yes | http://mikehadlow.com Location Brighton, UK Remote work: yes. GitHUb: https://github.com/mikehadlow Blog: http://mikehadlow.blogspot.com/ Email: [email protected] Twitter: @mikehadlow Hi I'm Mike Hadlow. Experienced .NET/C# developer. See my website: http://mikehadlow.com for details. My most recent client was 7digital. 7digital is Europe's leading B2B digital media platform provider. I helped 7digital build large parts of the Juke.com platform back-end, including authentication, payment systems and partner integrations (such as the SONOS music player). Juke is a streaming music platform built for Media Saturn to serve the German market.

The difference is that I am not proposing a Turing complete config language, but rather proposing to build configurations with plain old JavaScript (or whatever language you want). I think a good read about this thinking is by Martin Fowler on Language Oriented Programming [0], specially the section about internal DSLs. Another interesting read is around the configuration complexity clock [1], in that over time we move from hard coding things to building configurations to coming full circle and hard coding things again. I like to think internal DSLs closes that loop well. [0] https://www.martinfowler.com/articles/languageWorkbench.html [1] http://mikehadlow.blogspot.com/2012/05/configuration-complexity-clock.…

Reminded me of this great post: "Are Your Programmers Working Hard, Or Are They Lazy?" Key point: "To managers I would say, judge people by results, by working software, not by how hard they appear to be working." http://mikehadlow.blogspot.se/2013/12/are-your-programmers-working-har…

> The problem with that is making a configuration engine is a lot less efficient than just writing the code to do the damn thing. http://mikehadlow.blogspot.com/2012/05/configuration-complexity-clock.… It took me a solid decade to accept these lessons. I cannot build a product that even remotely competes with things like Visual Studio and .NET tooling. How many hours would it take a solo developer to recreate a debugger experience that anyone else could be bothered to look at for more than 5 seconds? The hardest part of building something configurable is the UI/UX. The moment you step outside of the host language, your tooling support goes to zero. Sure, you can pick other popular languages as the language of configuration (SQL, python, Lua, etc.) and piggyback off those ecosystems. But, you still have to build a way for a "non programmer" to visit all of the patchwork sites of "configuration" in a coherent way. Telling the business people to go edit a folder full of .py and .sql files will probably not be received well. Wrapping all of this with a fancy web interface doesn't make the problem less severe either (it makes it substantially worse). If you have a way to build/deploy your product in <60 seconds from source, worrying about elaborate configuration and customization architecture seems extremely idiotic to me now. The best path I've found is something approximating a common library and a per-customer executable that consumes it and implements the expected…

> the solution shouldn't be a smart algorithm to enable further mis-use of excel/spreadsheeting-tools, but rather to migrate the processes to a database In an ideal world only. Being able to have intricate computation definition being user-modifiable is a big feature. I have successfully 'appified' such Excel sheets in the past, only to be recognized as the new business rule maintenance guy. I no longer do that anymore: I identify moving parts, and these stay in the Excel world instead of going into the DB or a config file. I do clean the inputs and harden access control though. The apps are quite often low traffic so this setup might cost at most 100 USD/y in wasted performance per app. Nobody tracks that anyway. The business guys are happy to maintain the thing, I'm happy they're not bothering me. What is not so good is the latency of some queries. IMHO Excel is a great global minimum in the 'Configuration Complexity Clock' [1]. Or maybe I just don't care enough anymore. [1] http://mikehadlow.blogspot.com/2012/05/configuration-complexity-clock.…

I've done a few (started my career doing VB6 -> .NET porting). Working Effectively with Legacy Code was the first book I read. Email's in my profile Team just 'finished' a migration of a 10 year old codebase from Java -> Kotlin (ended up with 100k SLOC). Part-time this took around 1.5 years, which was faster than I expected. Seeing benefits already but it'll take years to see if it was worth the opportunity cost. Also in the middle of a second migration of some aspects of the codebase to Rust/Svelte. Massive and permanent immediate benefits when this goes through. - Have well-defined rationale, scope, and buy-in. - Determine how you'll approach bad code that nobody's touched for a long time - Testing guideline: ensure you 'could' test the code in the 'before' (typically about 15% coverage). If you can't test the 'after', you've probably picked the wrong language - CI is table-stakes. - Define the level of interop between old and new code that you want. - If you can avoid a 'big bang', do so. The burden of a 'big test' beforehand and 'everything is now unstable' afterwards isn't an easy situation to solve (still working on this). Nobody wants to be in the position of 'you did nothing and everything's worse' - Ensure you keep git blame working between old and new. git bisect is an ideal - Set up linting immediately for the new project - Optional: I went down the route of adding AST-based linting for a couple common errors/issues. Tempted to add some more. Didn't get…

I've seen this expressed similarly as the 'configuration complexity clock': https://mikehadlow.blogspot.com/2012/05/configuration-complexity-clock… I like your spiral metaphor though, since you learn some things along the way.

As much as I dislike them [1], DSLs are an easy way to provide domain specific backpressure to your llm which might not easily be available in your language. 1- https://mikehadlow.blogspot.com/2012/05/configuration-complexity-clock…

Is pandas a DSL for dataframes or a library? Beware https://mikehadlow.blogspot.com/2012/05/configuration-complexity-clock…

This reminds me of this post from 2013 -- https://mikehadlow.blogspot.com/2013/12/are-your-programmers-working-h… Essentially, there are two parallel teams, one is seen constantly huddling together, working late, fixing their (broken) service. The other team is quiet, leaves on time, their service never has serious issues. Which do you think looks better from the outside?

Configuration complexity clock https://mikehadlow.blogspot.com/2012/05/configuration-complexity-clock…

The configuration complexity clock: https://mikehadlow.blogspot.com/2012/05/configuration-complexity-clock…

No mention of The Configuration Complexity Clock [1] which I always think deserves a link, but credit to the author for actually keeping it slim and readable over (IMHO) most of the newer additions to the landscape which either declare themselves as 'obvious' and aren't or just add features such as Pkl's extends keyword, moving us further round the complexity clock. Of course just adding multiline strings is the start of the rabbit hole, now you need to think about leading line breaks, trailing line breaks, intermediate line breaks, whitespace chomping, and- oh heavens I've reinvented YAML, I think I need to lie down. [1] https://mikehadlow.blogspot.com/2012/05/configuration-complexity-clock…

> configuration with code https://mikehadlow.blogspot.com/2012/05/configuration-complexity-clock… is a post you might enjoy.

A friend of mine introduced TOML to a reasonably big open source project and he mentioned there were some unexpected downsides to it. I've asked him to chime in here, because I think he's more qualified to reply (note that I pointed him to a sibling comment that's also asking about TOML, here https://news.ycombinator.com/item?id=45295715). As for Apple Pkl, I think we share the goal of robustness and "toolability", but pkl seems way more complex. I personally think it's more useful to keep things simple, to avoid advancing in the configuration complexity clock (for context, see https://mikehadlow.blogspot.com/2012/05/configuration-complexity-clock…

Reminds me a lot of the configuration complexity clock: https://mikehadlow.blogspot.com/2012/05/configuration-complexity-clock… It’s made the page before and proposes that these forms are cyclic.

I find the configuration complexity clock always valuable in framing conversations like this: https://mikehadlow.blogspot.com/2012/05/configuration-complexity-clock…

I suppose you are referring to this: https://mikehadlow.blogspot.com/2012/04/database-as-queue-an... The main complaint seems to be that it's not optimal...but then, the frame of the discussion was "Until you hit scale", so IMHO convenience and simpler infra trumps having the absolute most efficient tool at that stage.

See also the Configuration Complexity Clock: https://mikehadlow.blogspot.com/2012/05/configuration-complexity-clock… . This is why I have a separate config language and code language. My config language is essentially JSON with newline separators and a first-class binary type (base64). I added little else. When I get the temptation to add code to it, I just pull out my other, general-purpose language instead.

once those custom codegen tools become established and popular, someone will have the idea that if they slap a GUI on the front it'll be much easier for non-engineers in the business to pick up and use. this is reminiscent of https://mikehadlow.blogspot.com/2012/05/configuration-complexity-clock…

The configuration complexity clock (https://mikehadlow.blogspot.com/2012/05/configuration-complexity-clock… is another description of the same phenomenon. The inner platform is the DSL at 9 o'clock.

> And contrary to many people, I'm fine with the (eternal?) limbo that we then end up with: parts of the codebase using the new stuff, parts still using the old stuff. That is fine when, as you described it, there are only two types of code: one still using old technique/technology A and the other using newer version B. Where it becomes a problem is when you haven't finished the transition and realise you need to start moving on to C, or you leave and the new person doesn't understand the difference (and probably also has their own desired replacement). Before you know it, you have three or even more styles of code in play at once, with diminishing ability to keep moving to the latest version. This is sometimes called the lava layer antipattern [1] [1] https://mikehadlow.blogspot.com/2014/12/the-lava-layer-anti-pattern.ht…

Relevant article (2012): http://mikehadlow.blogspot.com/2012/05/configuration-complexity-clock.…

Then you need some tool to coordinate and apply the data driven configuration such as Terraform or CloudFormation or you use DHALL or Cue. This blog post talks about what happens with configuration evolving into a DSL and then a rule engine. https://mikehadlow.blogspot.com/2012/05/configuration-complexity-clock… See configuration of Istio, service mesh, Traefik. And Kubernetes. Every system eventually becomes Kubernetes. (Ansible, CMake) The system to tell the computer how to do the work is more complicated than the work itself.