HNHacker News
TopNewBestAskShowJobs

gengstrand

157 karma · joined October 24, 2008

Advising 12 factor cloud native architectures with less complexity and more scalability for improved performance, lower cloud bills, lower maintenance costs, faster time to market, and more secure.

Current interests include AI (both predictive and generative), distributed consensus, and open source.

Currently exploring how LLMs can enhance and augment the developer experience.

You can contact me at media at glennengstrand.info

submissionscomments
gengstrand··on Garage: An open-source distributed object storage service
I remember working at a company that got started before cloud took off. They used mogile fs which I recently found at https://mogilefs.github.io/mogilefs-docs/HighLevelOverview.h... but I never hear about anyone else using it. It wasn't as stable as S3 but it was okay, I guess. Does anyone else here remember that distributed open source file system?
gengstrand··on Scala isn't fun anymore
While there are some language features in Scala that are a bit of a buzz kill (see https://glennengstrand.info/software/coding/java/scala for more on that), the OP is mostly complaining about https://en.wikipedia.org/wiki/Dependency_hell

The Akka BSL is a big disappointment to me as well but a better name for that would be LightBend isn't fun anymore.

gengstrand··on Becoming a Systems Architect
I like how an ex-boss of mine described it in his blog https://bradhenrickson.substack.com/p/establishing-an-archit... where architects "can either be advisory or decision making" and the latter is the old school ivory tower style of architect being alluded to here.

The prevailing sentiment here seems to me to be that we should do away with the title architect and allow senior developers to perform that function. I believe I saw a reference to Hohpe's "The Architect Elevator" as an example of the old school of thought in the comments here. Check out this guest blog of his https://martinfowler.com/articles/architect-elevator.html where he makes the case that senior developers should set the architecture for services and systems but that there is also the need (in larger organizations) for architects to advise on software portfolios and technology radars.

gengstrand··on Ask HN: How do you decide which language/tech stack to learn?
Your question is interesting to me. As a software architect, I study various tech stacks and programming languages. I concentrate mostly on open source and microservice architectures. I usually start with implementing the same feature identical rudimentary news feed microservice. Over time you start to see the similarities and differences between the various implementations. I blog about this over at https://glennengstrand.info and the source code can be found in https://github.com/gengstrand/clojure-news-feed

You are looking for a decision on what programming language and tech stack to learn next based on career mobility. Here are some questions to consider.

What kind of company are you most interested in working for? Think about the size of the company. Is it in a growth market or is profitability more important? Is it a technology company? Does the CEO view technology as a profit center or a cost center? Do they have a CTO? If they do, then who does the CTO report to, the CEO, the CIO, or the COO?

What kinds of programming languages and tech stacks are on the career pages for the kinds of companies that you are most interested in? Different kinds of companies tend to cluster around different tech stacks. There are other factors to filter for such as how deeply do they embrace remote work or commute distance to where you currently live or are willing to move to.

These are lagging indicators. They are going to be more accurate than leading indicators but that also might indicate that whatever you learn next based on these factors might have a shorter shelf life.

Finally, you should ask yourself what about your current programming language do you like? Try to pick something that you would also like. The Go programming language was originally invented as a better C and is enjoying some marketability right now. Maybe that would be something to look at.

gengstrand··on Clojure needs a Rails
I have a github repo where I implement a feature identical microservice in various tech stacks. I started that repo with a Clojure version that used community provided wrappers. See https://github.com/gengstrand/clojure-news-feed/blob/master/... as an example of calling Cassandra. Recently, I added another implementation with Clojure that just called the Java drivers directly. See https://github.com/gengstrand/clojure-news-feed/blob/master/... for that version of the same call. In the end, I decided to forego wrappers and make the calls directly because you end up with fewer dependencies and are more likely to be able to use latest versions of everything.
gengstrand··on Try Clojure – An interactive tutorial in the browser
Your claim, that the latency cost of reflection is small in comparison to the latency of performing I/O, seems reasonable assuming that the service is processing only one request at a time. That is not the case for typical microservice architectures and certainly not what is happening in the load test by which each of these service implementations are compared.

There is an upper limit of requests to which any service can handle concurrently. Usually, that limit is based on memory but there could be other factors too. After that upper limit is reached, additional requests wait in a queue or get rejected. From Little's Law, we know that the number of requests in any system is the product of the rate of ingress and the average time it takes to service a request. Since that number of requests is bounded, even small increases in the average process time can have a significant negative impact on the ingress rate that the service can sustainable handle. If you are not familiar with queuing theory, then perhaps you have heard of onlooker delay being the major cause of traffic jams.

Is running Clojure services with Java reflection the end of the world? Of course not. Just be aware that it does make performance for those kind of services look not quite as efficient when compared with services that do not use Java reflection.

gengstrand··on Try Clojure – An interactive tutorial in the browser
Most data focused microservices for business applications devote most of their code to calling databases. The PoC microservices that I implemented in order to evaluate Clojure use Java libraries to communicate with Cassandra, MySql, Redis, and Elastic Search. Clojure is not currently at a point in adoption where it makes a lot of sense for these database vendors to support native Clojure libraries.

While it is true that not every method calls goes through Java reflection, it is also safe to say that every API call to this kind of service will end up making a lot of calls via Java reflection unless you use types hints all over the place in the DAOs.

gengstrand··on Flutter is the most popular cross-platform mobile SDK
I recently blogged about a comparative evaluation of the three technologies you identified as cross platform (Flutter, React Native, Ionic) over at https://glennengstrand.info/software/architecture/ionic/reac... by implementing a feature identical PoC app in each tech stack.

The value of cross platform toolkits is all about cost reduction. It is cheaper to staff up on a single skill set rather than to staff up on three entirely separate skill sets. As of 2022, that single skill set is most likely web SPA development.

Flutter and Dart are no where near as similar to React or Angular as Ionic or React Native. Even the most experienced web developer will need time to learn Flutter. There are also some positives to Flutter that you should consider. Of the three PoC apps, the Flutter app had the fewest lines of code and took the least amount time to develop (once you know Flutter).

gengstrand··on Try Clojure – An interactive tutorial in the browser
I started playing around with Clojure back in 2014 by implementing a rudimentary polyglot persistent news feed microservice. That microservice used Ring which sits on top of Jetty. I blogged about that implementation at https://glennengstrand.info/software/architecture/oss/clojur... which is my personal blog. Last year, I re-evaluated Clojure with a feature identical microservice. This time, I integrated with Donkey which sits on top of Vert.x and https://glennengstrand.info/software/architecture/microservi... is where I blogged about that implementation.

I put each of these implementations in a load test lab where I collect then analyze the performance data for comparison purposes. Those two blogs include the performance results. It is hard for Clojure to compete with other tech stacks, primarily because each method call in Clojure goes through Java reflection which is pretty slow. There is a way to prevent the use of Java reflection in Clojure but then the Clojure code doesn't end up looking very Lisp like. The usual advise is to use type hints very sparingly like in hot spots in the code.

I still like Clojure, though.

gengstrand··on Ask HN: Great Blogs by Programmers
In this blog https://glennengstrand.info/blog/ I implement feature identical rudimentary polyglot persistent news feed microservices in various programming languages and tech stacks then compare them with previous implementations in terms of architecture, design, coding, and performance under load. I currently have 13 implementations of that same back end service in a freely available public github repo.
gengstrand··on Ask HN: What tech stack would you use to build a new web app today?
I have been exposed to many different tech stacks over the years. This https://github.com/gengstrand/clojure-news-feed repo contains the code used to evaluate thirteen different stacks which is what I can share publicly. What I can say is that the best choice of tech stack depends on what is being called for. Is this for an early stage startup or an intrepreneurial greenfield project? Is this for an MVP or just the next component in an already formalized microservice architecture? What are the skillsets of the developers that you will have access to? Have you reached agreement that you can throw it all away and start over or are you expected to have to live with the choice of tech stack for the life of the product? Are you mobile first? These are all important questions that very much shape the decision.
gengstrand··on Ask HN: What are some great engineering blogs?
I maintain a github repo where I implement a feature identical polyglot persistent microservice in various programming languages and tech stacks then I put each implementation through the same load test lab where I collect then analyze the performance results and draw comparatives. I blog about my findings here.

https://glennengstrand.info/blog/

gengstrand··on The Rise and Fall of the OLAP Cube (2020)
My first exposure to OLAP was on a team developing a front end to Essbase that semi-automated report generation after reloading the cube. Since then, I have worked with various OLAP technologies from Microsoft to Mondrian.

I agree with Mr. Chin who is the author of this blog. OLAP cubes can scale up but not out which limits their potential size so they can't really accommodate big data scenarios. My previous company used Apache Druid instead. Druid can do a lot of what OLAP did but using a distributed approach. Although Druid does not provide tight integration with spreadsheets, it does provide near real-time ingestion, on-the-fly rollup, and first class time series analysis.

gengstrand··on Ask HN: Favorite Blogs by Individuals?
If you are a manager / founder in a startup with a visionary interest in corporate culture, then you might find https://bradhenrickson.substack.com/ to be worthy of exploration. Brad has held leadership positions in a wide variety of startups and early stage companies so he is walking the talk with these personal blog posts.
gengstrand··on Clojure by Example (2015)
I maintain a github repo where I implement the same feature identical rudimentary news feed microservice in different programming languages and frameworks. Here is the social broadcast function in clojure.

https://github.com/gengstrand/clojure-news-feed/blob/master/...

and in python

https://github.com/gengstrand/clojure-news-feed/blob/master/...

and in node.js javascript

https://github.com/gengstrand/clojure-news-feed/blob/master/...

That last one is pretty old and predates async and await.

gengstrand··on Show HN: We wrote a book about building business applications in Go
Like I already said, inheritance is an advanced programming language feature that is easily misused. To give a specific example out of context would just leave you open to inventing context that would yield inheritance as an improper choice.

There is plenty of advice online already about how to use inheritance properly. In general, inheritance should be used to signal taxonomy. It should not be used to DRY unless there are good extenuating reasons behind that. There are lots of frameworks that require the use of inheritance which is somewhat unfortunate. You are most probably okay until you find yourself starting to form deep inheritance hierarchies. If you do have deep taxonomies, then consider modeling that in data (e.g. widgetType or widgetParent) instead of using inheritance. The decorator pattern is also used a lot when inheritance gets out of hand.

gengstrand··on Show HN: We wrote a book about building business applications in Go
https://www.youtube.com/watch?v=rFejpH_tAHM

“Go is software for the parts that we work on which is mostly infrastructure.”

Generics is a good thing and I look forward to seeing the details in how Go will support it.

gengstrand··on Show HN: We wrote a book about building business applications in Go
Go did rise to prominence by being the programming language behind such high profile software as Kubernetes, Docker, and Prometheus. None of those are business applications and Rob Pike (ex Bell Labs guru and co-inventor of Go) gave a presentation about Go in 2015 where he explicitly identified that Go was invented for infrastructure and not business applications.

I have encountered many engineers who are excited about Go and want to adopt it for enterprise systems. In 2019. I evaluated Go for that purpose. You can read my evaluation at http://glennengstrand.info/software/architecture/microservic...

What I discovered is that Go is not any faster than Java on a light weight framework. Here is the part that may seem controversial for the folks here. The simplicity of Go did not result in simpler systems.

I found that the lack of inheritance hampered me in expressing solutions to complex business rules and data models. Many of you may disagree with that and counter argue that inheritance is a bad thing. That is most probably one reason why there is so much interest in Go. It intentionally lacks support for inheritance. I agree that inheritance can and has been misused a lot. It is an advanced programming language feature that should be used sparingly. Removing inheritance entirely reduces the expressiveness of the programming language, especially when it comes to enterprise computing.

gengstrand··on Best practices for REST API design (2020)
The above referenced PoC service based on express uses https://github.com/apigee-127/swagger-tools which surfaces a web app by which front end devs navigate through the published API endpoints. They can use the web app to call the service via the endpoint or copy and paste sample code that calls the service. Most open api integrations support this kind of functionality.
gengstrand··on Best practices for REST API design (2020)
I also wanted to understand why GQL was getting so much attention in a REST vs GraphQL way so I implemented a GQL microservice that had the same features as a service that I had implemented previously as REST. Both services ran on node.js and connected to the same data stores, etc. I ran both services on the same load test lab and documented my findings at https://glennengstrand.info/software/architecture/microservi...

The TL;DR of that blog is this. There isn't much value that GQL can provide over REST + OpenAPI. GQL is still in its infancy so APM is easier with REST. The biggest argument for GQL is returning the right amount of data but GQL is slightly slower than REST because the server is having to parse what is essentially a mini program with every request.

gengstrand··on Obfuscating Complexity Considered Harmful
As a software architect, I can tell you that complexity is bad. For architects, there are two types of complexity; accidental complexity and essential complexity. The latter is inherent in the problem in that reducing essential complexity means that you are not solving the problem that you are supposed to be solving.

When I say problem, I don't just mean the functional requirements. I also mean the so-called non-functional requirements. If you are familiar with use cases or user stories, then you know of functional requirements. Non-functional requirements can take the form of Service Level Agreements but also include other metrics such as the costs to running the system and feature velocity.

Accidental complexity is unnecessary to solving the problem. It is a clear win to reduce that. Often you get to the point where you still have a lot of accidental complexity but cannot affordably reduce it any more. That is when you obscure complexity. That doesn't necessarily mean adding yet another layer of abstraction. It can also mean pushing the complexity from one already existing layer to another. This can be very helpful if the layer of abstraction that you are pushing the complexity too has a lower feature velocity than the layer that you are pushing it from. I have written on this subject over at https://www.infoq.com/articles/obscuring-complexity/

In this scenario, I would argue that obscuring complexity is not harmful. In fact, it can be quite helpful.

gengstrand··on Java Turns 25 – Whats Next? [pdf]
> Use Spring for frameworks.

Or Dropwizard if you want microservices that are more light weight and performant than Spring.

https://glennengstrand.info/software/performance/springboot/...

Or Vert.x or Play if you want to code reactive microservices.

https://glennengstrand.info/software/architecture/microservi...

> No one does inheritance anymore composition's all the rage.

Hmmm, that is oversimplification IMHO. When OOP first gained popularity, there was a lot of emphasis on inheritance. Inheritance got misused resulting in systems that became too rigid to change over time. The proverbial pendulum has swung the other way resulting in this sentiment of "no one does inheritance anymore" but inheritance is still very powerful and productive provided that you learn how to use it correctly. Think of inheritance as an advanced feature best left for more senior engineers to use.

gengstrand··on Solr 8.6.1
I remember load testing both ES and Solr about 3 years ago. What was tested was the indexing of randomly generated 500 word documents and keyword based search. When it came to indexing, Solr was faster but ES had better throughput. When it came to querying, Solr was the clear winner.

https://glennengstrand.info/software/performance/elasticsear...

gengstrand··on A REST View of GraphQL
Having written https://glennengstrand.info/software/architecture/microservi... which is a blog entitled "GraphQL vs REST" I must admit that I was initially on guard with this blog. In then end, they did compare and contrast GraphQL with REST. I don't wish to go over this article point-by-point but their main arguments against REST seems to me to be this...

1. too many endpoints

2. too much data retrieval

3. too much coupling between clients and servers

The blog does not discuss when to choose REST over GraphQL since that would be in conflict of interest with those who hold Hasura equity.

Technically, GraphQL does decrease the amount of endpoints to one but at the cost of increasing client-side complexity because now client devs have to write what is essentially a query. To do so, they have to understand the backend schema. I would argue that this is not the greatest in terms of clear separation of concerns. I would also argue that this means that there would be even more coupling between client and server.

I won't cover the n+1 point since others here have already done so.

gengstrand··on Ask HN: What are good solo developer blogs that you enjoy reading?
That is a great question. You are absolutely correct. I try to evaluate open source technology stacks that are emerging. I do feel like there is growing interest in serverless computing but most companies end up going with AWS Lambda which is not open source. I was wondering if the folks here are considering open source serverless technologies. If so, then which ones are making your short list?
gengstrand··on Ask HN: What are good solo developer blogs that you enjoy reading?
Whenever I evaluate a technology stack for microservice architecture viability, I implement the same feature identical polyglot persistent microservice then run it through the same load test as all the others. In that way, I can compare and contrast these various technology stacks. I blog about the results here.

http://glennengstrand.info

So far, I have covered clojure on ring, scala on finatra, java on dropwizard, javascript on node, python on flask, scala on scalatra, java on spring boot, go, and typescript on apollo (graphql).

gengstrand··on Why GraphQL? 8 Reasons After Reading 13 GraphQL Case Studies
Reason 3 "Strong Typing" is not an inherent advantage of GraphQL over REST. RESTful services that adopt Swagger can provide a typed schema and clients can call GraphQL services without any notion of type checking. http://glennengstrand.info/software/architecture/microservic... is a comparison between two feature similar microservices, one written in JavaScript on Express (REST) and the other written in TypeScript on Apollo (GraphQL). The RESTful service has a swagger spec and the load test application used to evaluate both performs no special type checking.
gengstrand··on Show HN: RPC Between Front End and Back End (Node.js) – REST/GraphQL Alternative
It sounds like what wildcard is targeting is early stage startups with single digit number of developers that are still pivoting heavily. Otherwise, you would already have encountered enough "structural problems" to arrive at a basic data model. In which case, why optimize prematurely with an API at all? Why not just go with an everything included MVC framework such as Django or Adonis? The only early stage startups that I know of that have to have an API are mobile first so consider adding Cordova and React Native bindings for the client.
gengstrand··on Show HN: RPC Between Front End and Back End (Node.js) – REST/GraphQL Alternative
I find the comparison to REST and GraphQL in this README to be a bit of a miss. GraphQL queries and REST add more value than just being another RPC. I cover this in http://glennengstrand.info/software/architecture/microservic... where I discuss how GraphQL queries and REST add order and structure that make their APIs more readable and understandable than just any RPC. I realize that there is currently brewing a backlash to this additional order and a desire to return to the simplicity of RPCs. This README is full of that attitude. It may be simpler to produce ad hoc RPCs but I believe that, in the long run, you will net an overall lower complexity if you design your APIs following REST or GraphQL guidelines.
gengstrand··on Why Go and Not Rust?
> BTW, the author claims Go is faster than Java. Is this true, because it didn't used to be?

I very recently ran an evaluation that included load testing feature identical business focused microservices written in both Java and Go. These are IO bound processes. The results are that, in this context, Go is on par with Java when it comes to performance (i.e. throughput and latency).

http://glennengstrand.info/software/architecture/microservic...

← PreviousPage 2 of 5Next →