In the same vein, Go+ is also interesting, and its being actively developed.
894 karma · joined November 22, 2015
https://lorefnon.me
I have used pgtyped for postgres, and missed not having something similar for sqlite. This library seems to perfectly fill the gap.
I know a lot of devs treat database schemas as sacrosanct and try not to modify the schema much once created. However, I do like being able to iterate on schema quite a bit during early stages of application and in case of dot-star queries I often end up with either run time errors or type errors that are quite far from the query itself. So now I have settled on ensuring that all columns are always specified in queries originating from application code.
I would have been perfectly happy to use CF if they added the notion of higher level constructs at CF level, but for whatever reason they haven't. So I use CDK because it provides the ability to reuse service compositions from third party libraries as well as across different internal projects.
CDK is imperative but imperatively building the configuration is not at all the same as imperatively managing the infrastructure. Even if with CDK the configuration is imperatively built you retain all the benefits of having declarative infra - version control, selective auto update, rollback to previous state etc.
Yes, while CF is clunky and slow, and I am sure everyone who uses it has at times gotten stuck with rollback failures, but CDK does provide a somewhat better dx on top of it.
Eg. If it is trying to be a generic markdown file editor, I wouldn't want it to insert yaml frontmatter without being more explicit about it. If it is trying to be a note taking tool, I'd expect to be able to interlink local markdown files and navigate files through them (I couldn't get that to work). If non technical users are the primary audience, the git integration may not be ideal sync solution for them. If it is for technical users, we would likely want to be able to edit the front matter ourselves (to add options specific to jekyll/pandoc or whatever else will use that markdown) etc.
However, I'd also agree with the GP comment. Its use of SWT ui results in some rather weird oddities. The biggest one is that if we configure gnome to use dark mode in linux, we get this absolutely unusable UI with barely visible text in many places. It becomes very obvious in that case which of the widgets are coming from gtk and which are custom rendered - and the distinction between them is stark.
And there doesn't appear to be a clear way to fix it without actually disabling the dark mode at OS level. I'd be perfectly fine if it used some framework that rendered its own widgets that looked a bit different or even if it ignored the dark mode completely and stayed usable.
The recurring complain I hear about scala are the bad compile times. I haven't used the language much, so not sure if this only applies to libraries that heavily use compile time metaprogramming.
But I really love that with modern tooling we can get a sub-second editor->browser feedback loop even for a three year old medium-large project on modern hardware. This was primarily one of the reasons I avoided Kotlin+Gradle JS target because among other issues the feedback loop was 2-3x slower.
But they may be an overkill if your primary use case is to infrequently build semi-interactive reports for non-technical end-users and your use cases are are mostly covered by standard graphs & tables. Esp. so if you are familiar with SQL and have access to the underlying data source. Two nifty utilities I have found to be very useful for latter kind of use cases are SQLPage and Evidence.
They make it very convenient to whip out some SQL and convert that to a neat professional looking web ui that can be forwarded to an end user. In case of Evidence it is a statically generated site, and in case of SQLPage it is a web app that connects to a live database.
SQLPage: https://sql.ophir.dev/
Evidence: https://evidence.dev
Sure TTFB (& potentially other web vitals) are better with SSR, but I still keep hearing SEO friendliness as a primary reason for SSR though prevalent crawlers like Google/Bing can index js loaded content.
I like the concept of classess css but most of the solutions I looked at (before pico) were just not very pleasing oob.
Posting this primarily because I frequently run into people who use kde but have never used krunner.
People are free to experiment with alternative cli utils which are not burdened by backward compatibility while nushell also remains easily adoptable by users who are accustomed to coreutils.
Kotlin recommend ksp [1] but underlying platform's reflection is also available. I am not sure it (or something similar) will be a great fit for gleam but have been planning to explore it deeper for some time.
So in theory we could get the raw body, and then use something like Jackson's ObjectMapper.valueToTree to get an untyped object hierarchy and then convert that to properly typed domain objects through some manually authored utility methods. Nobody does that though because it is super convenient to have a library take care of that boilerplate for you with codegen or reflection which was basically the point of my original comment.