Hull Devs is having another of their very popular developer events on the very last day of the month. On Wednesday 31st January at c4di in Hull you can hear talks dashboards and monitoring. These talks are really useful even (or perhaps especially) if you're a student. You can register here.
Last Wednesday in the month. Time for another Hull Devs. This means free food and drink (including those lovely white chocolate buttons with hundreds and thousands on them) and high quality technical chat. And, the most people I've seen there ever. It was packed. I think there was one seat free. It was the one next to me, which might tell you something about my personal magnetism. But then again maybe not.
I'd taken along my shiny ipad pro and Apple pencil to take notes, and happily scribbled down summaries of the talks. And then, less happily, discovered that the ipad had lost the lot. I'm doing a kind of highly expensive experiment where I try to find out if an ipad can replicate a proper computer. Experience so far is that it can't, except in the function of trashing your work.
Anyhoo, working from memory, we had two talks. The first was from Dylan Beattie. This was a great discussion on what makes for happy developers (and customers, and workmates). It was pleasing to find that a lot of the stuff I'd been telling students for years (make yourself a nice place to work, think about other people who might have to use your code) was echoed by Dylan, and he had some lovely insights into simple things that can make for happy times.
My favourite was the brilliantly simple "Give things names" suggestion. Rather than describing something as "The new version of the Customer Management App", name it after something, be it a particular "My Little Pony" or a east coast town. This provides an instant reference point for everyone.
The second talk was from Seb Lambda. This was all about restful services, and how to make them better. It's not a field that I'm particularly familiar with (although I do know a lot more now). The improvements are all about getting clever about how a client fetches information from the server and preloads data. Seb talked about some really interesting ways in which this is being explored in the latest version of ReST 3.0.
If you're in Hull, and you're a developer (or a student becoming a developer) you should go to Hull Devs. The next one is in the new year. Find out more here.
The next Hull Devs event is next week on the Wednesday 29th of November at 6:15 at c4di. They have a couple of interesting speakers; Dylan will be talking about Life, Liberty and the Pursuit of APIness: The Secret to Happy Code and Seb Lambla will be talking about ReST 3.0 - A Lap Around HTTP API's Next Generation.
There are free goodies and we always finish up in the pub. I'd suggest that you sign up now. You do it here.
Hull Devs is going from strength to strength. Hot on the heels of the talk last month we have another great talk, this time from Mathew McLoughlin who told us all about CQRS and Event Sourcing. At the start of the evening I had no idea what any of this was about. But by the end of the evening I was up to speed.
CQRS stands for Command Query Responsibility Separation. But knowing that doesn't really help you understand it at the start. The Event side of things is a much better place to begin.
If you are implementing something complicated (Mat used hospital admissions as an example) you could do this by having a record for each item in your system. You could fill a patient object full of things like like name, age, whether the patient is in the hospital, their ward number etc etc. Your system could then update these records each time the patient changes state.
This would store the data, but if you work this way a lot of information gets lost. If you want to know which wards a patient has been treated in, then a system structured like this will not be able to tell you. Furthermore, you're not really capturing what is going on, which is that people are arriving in the system and stuff is happening to them. Instead you're forcing users to update small parts of a large data object (the patient record) each time.
Rather than looking for the data you need to store, better to look for significant events in the trajectory of your objects, and build a system that captures these events. When a patient arrives, moves wards, gets test results and finally goes home, you record these events and your system can then then "play through" them to build a picture of the current state of your patient. It's a very nice way to work. Want to find out the state of your hospital last week? Just run the events to that point and stop. This reminded me a bit of "block chain" currencies where the movement of a lump of money is traced from person to person as it is used to pay for things.
Mat suggested "Event Storming" meetings with the customer to identify events and what effect they have on object state. This involves lots of paper, post-it notes and the development of a common language between customer and developer. And sounds like fun.
OK, but what about CQRS? Well, events are a great way to get stuff into a system, but if you want to view the state of your data you have to do a bit of work. The "Command Query Responsibility Separation" part really means that "projections" of the data in response to queries should just consume events and use them to build the view of the data. The storage of the events should be the responsibility of a totally separate process. This makes the design of the system much easier. The only downside is that your view of your system may be a tiny bit behind the times, as your projection updates in response to events, but in a modern implementation this should not be a problem.
It was a great talk, very interesting. Mat has built some C# that demonstrates this which you can find here. I'm looking forward to the next one.
Hull Devs is shiny new. They have T shirts. They have free crisps. And beer. And they meet up at on the last Wednesday of every month at c4di. And we end up in the pub.
Joe Stead, the man behind a really good talk a while back, returned to Hull with Richard Tasker, who gave a lovely talk about the Raspberry Pi. I know a bit about this device, but Richard put me onto some interesting new directions which I'm looking forward to exploring.
If you're a developer in Hull you should go along to Hull Devs. They've got a great programme of talks running into 2018. It's also a great place to meet up with other developers from the Hull area. And don't forget, there's also the awesome CodePen sessions (the next on is on 9th October) and of course our hardware meetups (the next one is on 5th October).
It's great to see all these initiatives taking off in the areas. Thanks to Joe and his sponsors for getting the ball rolling.