synthc

Another reminder that VC-funded hosting does not last forever. Self-host your mission critical dependencies folks!

SEEKING WORK | REMOTE (EU timezone)

I'm available for part-time contracts or short consulting gigs in addition to my main assignment. My main assignment ends this summer, also open to discuss longer full-time engagements after that.

Skills:

- 15 years of experience in companies ranging from 5-person startups to huge multinationals, MSc in AI

- Deep experience with Kafka, streaming processing and adjacent tech: designing messaging based architectures, fixing bottlenecks.

- Rule modeling and discrete optimization with Optaplanner, Google OR-tools & MiniZinc.

- Building prototype apps for visualization and decision support with ClojureScript.

See profile for contact details.

It doesn't have to scale if the rates are high enough.

Any references that prove this? I have been skipping breakfast for years, and feel fine. Eating breakfast makes me feel sluggish

Think again.

Nice anecdote, but was it because of the language or because a small motivated team gets much more done than a big enterprise that is bogged down in meetings?

Based on one guy who did a hobby research project based on GitHub issues?

Having used both statically and dynamically typed languages, I don't think this is true at all.

Most modern languages are pretty close in productivity, architecture and the way a company is organized have much more impact on productivity.

In big enterprises every small change requires 3 meetings, in a startup you can just make the change.

Shell productivity tools like fish, fzf and z.

Feels like doing parkour on the command line!

Yes Maven uses XML.

I'm fine with Java copying features. I'm happy to use Kotlin now while it is ahead, no problem with switching back to Java once it catches up.

Linux has xdg-open to open files from the terminal

I would also not normally connect to a REPL in a production environment, but it can come in handy.

One can certainly attach a debugger to a running process in production, I've done it several times to debug gnarly issues.

True, for Java and Kotlin I use the debugger in IntelliJ like a REPL all the time. You can even evaluate arbitrary expressions, connect to running applications even applications running on another machine.

It's not as powerful as a proper lisp repl as you cannot redefine functions or classes, but it is still very useful.

It's just the evolution of a marketeer.

Seems like all the NoSQL databases eventually implement SQL, maybe we should use EventuallySQL instead NoSQL

Use a recording in your presentations instead of a live demo A video usually feels "real" enough to an audience, but you can avoid crashers or unexpected inputs.

Has anyone used propagators in practice? I find it a very interesting concept, but have not encountered it in the wild.

for prototyping a long running repl is fine.

For validation/testing starting with a clean slate takes away a lot of my worries.

My theory is that some people get really attached to the language and take criticism to it personal. See the comment above where someone says 'I feel compelled to defend the honor of my favorite language'. It does get cult-like at times, which is too bad as adressing the failings instead of ignoring them would improve the language and increase adoption.

But programmers should be worried about every what-if scenario, regardless of language.

deps.edn is a building block not a finished build tool. You need to import libraries for common tasks like building an uberjar.

There are plenty of reasons to start a new REPL: - adding a library

- changing the project config

- messing up the repl state

- starting with a clean slate

- switching branches

In my experience the Clojure community is pretty tone-deaf when it comes to critisim. The usual response being something along the lines of 'your problem is not a problem, it was meant that way'.

I was wondering where this 1 return practice originated from, but yeah, it makes sense in that context.

Macros

Yes this is exactly what I meant. After years of coding in Haskell and Clojure, and then going back to Java I have absolutely no problems with

    int max(int x,int y) { 
      if (x>y) 
        return x;
      else 
        return y;
   }

I just looks completely fine to me, but colleagues would complain about it in reviews and I just don't understant the problem at all. The variant with the extra result variable looks just wierd to me, and I have seen much uglier code written by people desperately avoiding early/multiple returns.

Yes this is an excellent example of different cultures and ecosystems.

In Python a library like requests is a thin abstraction over http calls it is very easy to understand what is going on and get started.

In Java, there is a tendency to wrap everything so it fits with a framework and is super generic and configurable. For example look at the Feign library.

Each approach has its pro's and cons, but knowing both of them good as it allows you to pick the right solution for different use cases.

About getting into java: i'd recommend using Spring Boot. I provides a low abstraction http client (RestTemplate) that allows for straightforward calls to REST services.

Different languages also have their own culture and ecosystem, which are also valuable to learn in order to get a different perspective.

Some things that are taken as best practices are bad practices in other langauges and vice versa.

For example, lots of Java devs are against early and multiple returns to the point of absurdity, while in functional languages this is idiomatic and no problem at all.

Using different languages lets you see how different approaches work out in practice, so you can get a better view about which approaches work and which approaches are just cargo-cult nonsense.

And what solution would you suggest here? I'd like to hear it. Preferably one that does not setup Russia for another invasion in a couple of years, like you know, when they took Crimea.

I've worked with Clojure for years using the REPL driven approach and found I needed restarts quite often, for example when adding updating dependencies or other changes to the project file.

REPL driven development is great, but sometime you want to make sure that you are not using some function that was only defined in the REPL session but not in the source code. Also the REPL session sometime gets in a bad state when printing big outputs, blocking forever with some concurrency stuff or other mistakes.