HNHacker News
TopNewBestAskShowJobs

meekins

167 karma · joined November 24, 2014

submissionscomments
meekins··on What makes you enjoy Go lang?
It's a great relaxation language for hobby projects. After a day of cranking out tight functional style Typescript at $DAYJOB it's refreshing to work in a "stupid" language where the space to search for the most elegant solution is rather limited. You're just telling the computer what you want it to do in a very explicit and plain way.
meekins··on Ruby on Jets: Like Rails but serverless
Serverless runtimes don't shut down the instance immediately after the invocation is complete but keep it up for an undetermined time depending on many factors (usually ~15 minutes) in order to process a possible new event without the start-up overhead (cold start). This means that in a system with constant traffic some instances may have a surprisingly long uptime. The instance gets destroyed when it throws an error though so a function with a disabled GC would clean the state when it runs out of memory. Slower processing done by memory-starved instances would probably eliminate any minimal performance gain you could get by disabling the GC though. (EDIT: I just realized that with no GC desperately spinning in place the starvation would not have much performance impact so this would actually be a very interesting approach if you can tolerate some invocations erroring out on out of memory errors, sorry!)

In regards to performance optimization of Lambdas, start-up time is the most important factor as cold starts happen also in cases of concurrent requests when no warm instances are available. This means that Go, Node and Python are pretty sweet for serverless. Thanks to recently released Lambda SnapStart feature that launches new instances from snapshots taken after application initialization Java (even with DI frameworks) is a plausible option if you're inclined that way. Previously you had to use a custom runtime and AOT compilation (that rules out any runtime DI stuff) to achieve tolerable performance with Java on Lambda.

meekins··on Ruby on Jets: Like Rails but serverless
I stopped using the Severless framework when CDK came out. For simple cases it's still fine I guess but a lot of time I found myself falling back to plain CloudFormation (ugh) or relying in plugins with questionable maintenance status. I would not recommend it for new projects and even AWS SAM makes applying some best practices like least privilege principle easier.
meekins··on Ruby on Jets: Like Rails but serverless
In contrast to provider-native serverless solutions, cloud agnostic solutions carry a high price tag for the entire application life cycle in form of operations - those people petting your k8s. A common misconception regarding serverless applications is focusing on compute alone and in that context an agnostic solution may seem lucrative after traffic reaches certain threshold, justifying running a cluster 24/7. However many scalable application architecturs benefit from asynchronous processing and event-driven models which require reliable messaging infrastructure with considerable operational overhead. This is where serverless applications utilizing managed services shine, making it possible for small teams to deliver very impressive things by outsourcing the undifferentiated ops work to AWS. On the other hand, if the compute layer is the only lock-in-inducing component in your architecture, a properly architected application is relatively easy to migrate to a serverful model. As a crude simplification, just replace the API Gateway with Express.
meekins··on Modules, not microservices
Or module level state (Go, Python) which is in many ways even worse
meekins··on Ask HN: How many computers you got?
- Work laptop running Linux

- Sofa laptop running MacOS

- Raspberry Pi running Linux (RetroPie)

- SFF gaming desktop running Windows 10 Pro

- reMarkable 2

- Two Android phones (work & personal)

meekins··on Store SQLite in Cloudflare Durable Objects
> we'd only be able to offer real "edge compute" to a small number of big enterprises with deep pockets, rather than at prices affordable to everyone

What a nice way to formulate the tradeoffs between cost and security. When Workers came out with huge headlines about performance and cost I was very disappointed to find out there was no special technical wizardry behind that but just conscious trade-offs in disregard to customer data security. Workers simply skip all the sandboxing steps other providers take to implement a multi-tenant application runtime in a secure manner. So far the mitigations in place seem to make the possibility of Cloudflare customers getting bitten by a V8 vulnerability unlikely instead of impossible.

Sure, the platform has interesting ideas and I'm looking forward to try it out as a full-stack serverless platform. I just cannot foresee running anything serious on it before they come up with a more convincing security story.

meekins··on Anti-Patterns to Avoid in Lambda Based Apps
Security, ability to outsource pretty much everything ops-related besides cloud resource provisioning and deployments to the cloud provider and developer focus on business logic.

I don't know a better dev environment than a (possibly scaled down) personal replica of production environment in the cloud. With proper tooling (e.g. Serverless Stack or SAM) you can achieve very fast code updates so the old argument of slow feedback due to having to deploy changes to the cloud on each iteration is getting less and less true as well.

With more traditional models already keeping your OS, possible container images, web server and any other middleware secure and up-to-date is pretty expensive if you want to do it properly.

Going all-in on serverless might not make much sense for a large software product company but when building bespoke business software it allows small teams to do wonderful things very cost-effectively.

meekins··on AWS Lambda Cold Start Times
> consistent and pervasive security model with Azure AD

Wait, this is the first time I hear this about Azure. Could you elaborate? It is possible that things have improved significantly since I last worked with Azure but lack of a consistent security model (like IAM on AWS) to control human and service (Azure Functions, App Service apps etc) access to specific resources (Cosmos databases, EventHubs etc) especially painful.

meekins··on Almost free serverless on-demand Minecraft server in AWS
To me a DNS lookup spinning up a container on Fargate looks both very cool and scary at the same time.
meekins··on AWS Cost Saving Recommendations
Sounds like optimizing data partition and blob sizes in Athena and/or Glue
meekins··on Did we market Knative wrong?
The most common approach I've seen is lift & shift to a VM and possibly some devops pixie dust on top to adopt golden image deployments.

My perspective is limited and evidence anecdotal but I've seen only one on-prem to serverless "migration" project so far and that was a complete rewrite. The original codebase was ~20 years old, had a tight dependency on an expensive proprietary database and a variety of scalability issues so it would have needed thorough rearchitecting anyway. A more common pattern is to do the lift & shift and incrementally either create new services or migrate existing ones to serverless where it makes sense (the strangler pattern).

meekins··on Did we market Knative wrong?
I do custom enterprise software and there the story is somewhat different. In that landscape many existing workloads are either being migrated to VMs or containers in the cloud or replaced with new cloud native applications. Companies are eager to have as minimal on-prem setup as possible (mostly for legacy software too difficult or risky to migrate).

For entirely new applications serverless solutions are usually the first option to be considered since they are very easy to operate. Many clients also don't have much expertise in-house for operating k8s so new workloads would be operated by outsourced ops teams or development teams themselves which is very expensive. Large enterprises also have formed some sort of "strategic partnership" or alliance with either Amazon or Microsoft so cloud agnosticism rarely enters the picture. In addition to being easier to operate, skilled development teams are also very fast to deliver on serverless since there's very little infrastructure-level things to worry about. The team can focus on business logic and delivering value from day 1. If you only look at Heroku I can assure you the market for serverless is much bigger and constantly growing.

meekins··on Ask HN: Favorite purchases of last two years?
This was also my concern after reading the reviews on the first model. I'm not the world's fastest hand-writer so I found the device surprisingly snappy and the latency - while perceivable if paying close attention to it - hasn't really bugged me at all.
meekins··on Sublime Text 4
Congrats on the release!

Are there any plans for some kind of combo deal now that Sublime Text and Sublime Merge licenses are aligned?

meekins··on Ask HN: Favorite purchases of last two years?
reMarkable 2. I was looking for a sketching and note taking tool and got a decent eBook reader as a bonus. The UX is very nice and distraction-free. It works surprisingly well for drawing as well.

My only complaint is the lack of Linux support for the app that allows mirroring the screen to a computer. Would be really cool for sketching stuff during online meetings.

meekins··on Ask HN: Does anyone else find the AWS Lambda developer experience frustrating?
I've been working on serverless applications for years now and the cases are quite rare TBH.

Static cost of data streams come up in data projects but even there it's trivial to consume data from shared streams in developer-specific environment since the stream pointer is managed in client side. The throughput required by even multiple occasionally consuming dev environments rarely requires provisioning streams above minimum capacity.

DynamoDB in on-demand mode is my go-to OLTP database until I know enough of runtime load characteristics to provision static capacity with autoscaling. For any non-prod (or load testing) environment on-demand mode is the best choice. Aurora Serverless is OK as well but has its warts and so far the cases where I really need a relational database in a greenfield project have been few and far between. Anything with complex query requirements goes to S3 and gets queried asynchronously or in batches via Athena. Not suitable for real-time cases though.

Things like queues, notifications and e-mails are handled by SQS or SNS and paid per usage. Websockets by API Gateway and Lambda.

Architecting for serverless requires a shift in mindset and tooling but as a benefit you get cheap isolated development environments and truly elastic production environments with very little ops burden.

meekins··on Ask HN: Does anyone else find the AWS Lambda developer experience frustrating?
> the next step tends to be remote integration testing on the actual cloud hosting service, using some sort of separate staging infrastructure that will possibly be shared among many developers

One of the results of the pay-per-use pricing model of services utilized in serverless architectures is that you can easily provision dirt-cheap developer and feature-branch specific environments for integration-level testing. While you still can't attach a debugger in your function, the isolation from changes others are working on makes testing and exploration much more pleasant than when working in a shared dev environment. Things only get complicated when your architecture includes more expensive components with different pricing schemes that you probably want to share with others (e.g. relational databases, data streams).

meekins··on Ask HN: Why do you use the Linux distro that you use?
Fedora (KDE Spin): Good compromise between reliability and bleeding edge, decent compatibility with my laptop (ThinkPad Carbon X1), the best KDE experience out of the box, some sysadmin skills directly transferable to RHEL
meekins··on Ask HN: Desktop Programming Language
This is a very interesting question! Aside from somewhat difficult (C/C++), non-native (Electron) and perhaps too platform-specific (.NET stuff) the alternatives for easy desktop GUI development are rather limited: - Python apps with a GUI library (e.g. Qt) are nice to develop difficult to package and distribute - Go with a GUI library (e.g. GTK) resolve the packaging and distribution problems but might be a bit more difficult to learn than Python - Lazarus gets recommended a lot. You have to be comfortable writing Pascal however

If you're into Lisps the Racket GUI library is really nice and actually looks like the easiest option for developing native GUI applications with capability to build for different platforms.

If the you're targeting Windows only then .NET + C# is probably the best alternative. Not the easiest platform to learn but you'd be learning skills that have more demand on the market.

meekins··on Show HN: An Event Sourced Minesweeper
Oh, it's in Elm. Cool! I'll definitely read the code later today and hopefully learn something. Did writing this reveal any interesting pros/cons regarding event sourcing in contrast to a stateful implementation?

Minesweeper is such a cool exercise when learning new stuff. A co-worker challenged me to write this crude implementation on a flight from Heathrow to NYC while I was learning Go: https://gitlab.com/joyey/kakkamiina

meekins··on Show HN: Test Your Front End Skills with These JavaScript Interview Questions
For anyone wondering the lack of content on the page: at least AdBlock Plus blocks it.
meekins··on Improved VPC Networking for AWS Lambda
This comment doesn't seem to make sense, could you elaborate a bit? How would you replace the database working as a persistence layer to an API application by polling an event stream?
meekins··on Ask HN: Products that suck but you still use?
LastPass. Often unstable, horrible client with bad UX but works well enough most of the time for the customer not to consider switching to an alternative.
meekins··on Sample cloud-native application with microservices
I'd say a bounded context is a better border. When doing REST you can then begin by implementing each of your aggregate roots within the context as a resource.
meekins··on Cloud Programming Simplified: A Berkeley View on Serverless Computing
You can absolutely do that. Then you just need to do more custom work to enable route level observability and metrics.
meekins··on Cloud Programming Simplified: A Berkeley View on Serverless Computing
The interface between Lambda and your business logic is usually very thin so in case of simple REST APIs migrating from platform (as long as the target platform has a compatible language runtime) to another or to be executed in a web app framework is rather easy.

Serverless applications' reliance on other proprietary services like Cognito, DynamoDB etc is another thing however...

meekins··on Cloud Programming Simplified: A Berkeley View on Serverless Computing
API Gateway becomes your HTTP server, your routing layer defined in Flask/Sinatra/Express & co is implemented in API GW integration configuration and handling routed requests is implemented as Lambdas that process events from API GW.
meekins··on When AWS Autoscale Doesn’t
Hmm... I don't see anything in the docs implying that - Kinesis API docs say it's possible to ingest 1000 records or 1MB per shard per second. There's a 5/s limit on reads however but those deal with batches of records anyway.

We have one service running that consumes data to a Kinesis stream published as an API GW endpoint. Preprocessing is done in Lambda in batches of 100 records and the processed records get pushed to Firehose streams for batched loads to a Redshift cluster for analytics. So far we've been very happy with the solution - very little custom code, almost no ops required and it performs and scales well.

meekins··on “Lambda and serverless is one of the worst forms of proprietary lock-in” (2017)
How is the Aurora Serverless Data API now? On preview release it was a bit sketchy: horrible latencies (pretty much ruining any benefit you could get from avoiding the in-VPC cold start) and a dangerous sql-query-as-a-string API (no prepared statements or placeholders for query params that would get automatically escaped IIRC).
← PreviousPage 2 of 4Next →