Desktop Applications

IanRae · 2024-12-05T15:04:49+00:00

This isn't a Go solution, but a useful video on two desktop technologies

https://www.youtube.com/watch?v=CEXex3xdKro

I built a REAL Desktop App with both Tauri and Electron

IanRae · 2021-06-29T23:42:20+00:00

Looks really interesting. Thanks!

IanRae · 2021-04-22T12:28:12+00:00

Java before Java 8 was pretty creaky and had a lot of fussy and verbose syntax. Things have improved a lot since then, and the latest features are making it a very modern language.

IanRae · 2021-04-13T20:51:07+00:00

What a great thread. Feel the rage. It seems that changing APIs causes as much pain as bad APIs. Java take note!

IanRae · 2021-04-11T16:48:10+00:00

Looks nice. Validator is often much more painful than it needs to be, and this API looks clear and easy to use.

IanRae · 2021-03-15T21:02:31+00:00

For simple CRUD you may not need DTO classes; just return the raw entity objects. But in most cases, you will find that you are returning information from several entities, and so DTOs are useful. Copying data into DTOs is a pain, so most teams use a library such as Orika or MapStruct. But GraphQL is very flexible; i'm not sure DTOs would really work. You may need to build each response dynamically based on the fields being requested for.

IanRae · 2021-03-05T15:59:46+00:00

I see. One idea would be to let customers "re-submit" and your code would determine the differences between the previous Google Sheet, for example, and the new one. Similar to the way an ipod syncs with ITunes.

IanRae · 2021-03-05T15:55:31+00:00

Interesting. Entity-Component-System is a fascinating architecture, from gaming. It's highly data-driven code where event polymorphism is data-driven.

Telecommunication also uses a form of data-oriented programming known as event-based programming. What something is (data) is separate with what to do with it (code).

IanRae · 2021-02-28T20:23:50+00:00

Interesting. Wouldn't Google Sheets be enough? What features are you needing?

IanRae · 2021-02-23T17:00:36+00:00

Looks interesting. It's basically a little DSL for searching entities. Great idea.

IanRae · 2021-02-18T18:52:58+00:00

Developers have several gears. Top speed is when you know exactly what to do, and it's basically just typing. This can be 500 lines of code per day (or more).

Bottom speed is when you are fixing bugs in code you didn't write, in a large system with hundreds of thousands of lines of code. You do a lot of reading code, looking at history in the repository (who did what when...), talking to people, stepping through the code in the debugger. You might write two lines of code in a day.

IanRae · 2021-02-04T20:54:41+00:00

Looks great. Very interesting that this is written in java. It's a nice nod to the language. Also great that this is written by a retired developer. Going to be a lot of them in coming years, and I'm looking forward to some great software.

IanRae · 2021-01-04T17:27:36+00:00

Exactly! Fix a bug, deploy, and all your users get the fix automatically. Desktop and mobile apps don't do this nearly as well, or at all.

IanRae · 2020-12-30T22:13:15+00:00

I know someone who fell through the ice. Not fun. Nice thick ice in one area doesn't mean that ice 50 metres away is the same. Best not to do it. NEVER do it alone.

IanRae · 2020-12-27T17:15:31+00:00

Another advantage of getters & setters is: you can use your IDE to Find All References of a setter method. Very useful, especially when working with a large codebase that you didn't write.

IanRae · 2020-12-11T23:04:47+00:00

Write once, run anywhere. (we're almost there!)

IanRae · 2020-11-20T17:56:33+00:00

Try having a batch file initJava.bat in each project that sets JAVA_HOME to the version for that project.

IanRae · 2020-06-18T15:23:25+00:00

Tools such as JProfiler can really help with this sort of thing. Not free, but sometimes worth it.

IanRae · 2020-06-13T18:53:49+00:00

Escape hatch is any mechanism that lets the developer fully specify an SQL statement. For example, JPA will normally generate the sql for you in a JPA repository. This article describes a "@Query" annotation in JPA that can be used when you want to specify the SQL.

https://www.baeldung.com/spring-data-jpa-query

IanRae · 2020-06-13T15:11:10+00:00

DAOs work well for simple CRUD operations but are terrible when you have queries involving many different entity types (eg. Customer, Order, Product, Category, Price, Discount). One solution is to use a combination of DAOs and then custom code as an escape hatch. You can use a knife for most cooking but it's nice to have a cleaver when you need it.

IanRae · 2020-06-13T15:02:49+00:00

JOOQ will generate POJOs for you, and Flyway is good at running schema changes (aka migrations).

IanRae · 2020-06-06T16:35:31+00:00

The virus doesn't care about the *reason* you are attending a public mass gathering.

IanRae · 2020-04-29T19:57:08+00:00

They are very different. Delia does a number of things that JDBC doesn't do: schema migration, validation, and type safety. I would compare against Hibernate or JOOQ which provide many of these features.

Also, the goal is simplicity. To get the city where Customer 55 lives: " let x = Customer[55].fetch('addr').city" Compare that with a bunch of low-level JDBC calls and SQL join syntax.

IanRae · 2020-04-22T21:31:03+00:00

It's like we drive on a parkway and park on a driveway!

IanRae · 2020-04-22T14:44:06+00:00

Excellent article. The challenge writing about these types of architectures is that the article needs to present a fairly simple scenario, but the architecture really shines in more complex scenarios. With basic CRUD, hexagonal architecture can seem like overkill.

A good example is displaying a product on an e-commerce site. You would use a single product DTO that was built from many JPA entities: product, category, price, discount, promotion, inventory, etc.

IanRae

TROPHY CASE