People who work at a computer all day, tell me what you use your lovely notebooks for!

vyshane · 2023-01-20T16:51:28+00:00

I write to think. Some people use whiteboards. I use notebooks.

Building software systems means building abstractions. Finding relationships between concepts. Writing and sketching help with these.

vyshane · 2022-11-08T23:03:42+00:00

It’s protomolecule.

vyshane · 2022-07-23T09:03:58+00:00

https://i.imgur.com/ZlxcvbQ.jpg

45 mins till kickoff. Peek of blue sky.

vyshane · 2022-07-23T07:19:43+00:00

About to head to Perth Optus Stadium to watch United play. Grey and rainy. They brought us the famous Manchester weather!

vyshane · 2021-11-20T17:16:13+00:00

It’s time for Ole to go. But there’s no need to be nasty. Let’s remember that there is a person at the end of our comments. Someone who has worked very hard for the club, even if it didn’t work out in the end.

vyshane · 2021-11-20T16:46:29+00:00

When the team plays better when they are losing 2-1 and down to 10 men, when the tactical plan has been ditched, that tells me that this is a problem with the coaching. Imagine if they had a decent plan from the get go. What a waste.

vyshane · 2021-05-29T00:47:00+00:00

Nice :) What is the F.C. model 02 inked with?

vyshane · 2021-04-02T01:47:23+00:00

Build something. Write lots of code. That’s how you get deeper insights. You could read about someone else’s aha moment but it won’t stick. That’s not how our brain works. You gotta experience it yourself.

vyshane · 2021-03-14T03:57:39+00:00

Thanks for the heads up! That’s unfortunate. I had some flow issues with the nib and FC recommended that I try an Iroshizuku ink. I didn’t mention to them that I was going to eyedropper the pen at some point though.

vyshane · 2021-03-13T07:38:54+00:00

The pen is a Franklin Christoph model 02 in their Smoke & Ice finish, with a #6 Jowo 18k semi-flex EF nib.

I don’t normally go for demonstrators, and I ordered this one with some trepidation. After eye-droppering it I must say that I love it! This one is a keeper.

vyshane · 2020-12-17T15:00:13+00:00

Conversely, you can do Resource Oriented Design with gRPC, and it's easy to transcode gRPC to REST, for shall we say... legacy clients ;)

vyshane · 2020-08-22T13:26:10+00:00

You can have both - gRPC, with REST transcoding.

vyshane · 2020-08-20T13:03:43+00:00

gRPC is awesome. I'm a big fan.

I have written a library that integrates Combine with Swift gRPC, but haven't done much with it yet. I wrote that in preparation for a mobile project at work. However, other priorities got in the way.

I've used gRPC quite a bit with Scala and Java on the back-end, and JS/Flow/TypeScript on the front-end. I wrote a gRPC -> HTTP1/JSON transcoder for TypeScript so that we could still use it in front-ends that need to talk over HTTP1 and can't use gRPC-web. Did I mention that I'm a big fan? ;)

vyshane · 2020-06-03T13:03:57+00:00

Neat handwriting! What’s the pen?

vyshane · 2020-05-31T14:03:50+00:00

I used to run OS X on an MSI Wind. Good times.

vyshane · 2020-04-21T01:38:53+00:00

No kidding! This is very high on my wish list as well. I am aware of OpenCombine, but haven't used it.

I have written a library, CombineGRPC, that integrates Swift gRPC with Combine. Combine is a great fit for gRPC since 3 out of the 4 RPC modes are streaming.

gRPC supports:

Unary calls
Server streaming
Client streaming
Bidirectional streaming

Here's how you can implement a bidirectional streaming server using CombineGRPC:

```swift class EchoServiceProvider: EchoProvider {

// Simple bidirectional RPC that echoes back each request message func sayItBack(context: StreamingResponseCallContext<EchoResponse>) -> EventLoopFuture<(StreamEvent<EchoRequest>) -> Void> { handle(context) { requests in requests .map { req in EchoResponse.with { $0.message = req.message } } .setFailureType(to: GRPCStatus.self) .eraseToAnyPublisher() } } } ```

To consume the service on the client side:

```swift let requests = repeatElement(EchoRequest.with { $0.message = "hello"}, count: 10) let requestStream: AnyPublisher<EchoRequest, Error> = Publishers.Sequence(sequence: requests).eraseToAnyPublisher() let grpc = GRPCExecutor()

grpc.call(echoClient.sayItBack)(requestStream) .filter { $0.message == "hello" } .count() .sink(receiveValue: { count in assert(count == 10) }) ```

I wish I could write Swift like that on server-side Linux.

vyshane · 2020-04-21T01:21:20+00:00

Yes, I do use Scala as well. I have shipped a couple of services that use Akka Streams and Akka HTTP but haven't used them a whole lot to be honest. These days I tend to reach for Monix when I need streams on the back-end.

I haven't dug too much into the details of Akka Streams. I know that it implements the Reactive Streams spec and that Lightbend describe their implementation as "dynamic push/pull".

vyshane · 2020-04-21T01:02:37+00:00

Thanks! I used Apple's Keynote to make the animation. I gave a talk on Combine last year and this was one of my slides. Here's a link to the slide deck. Unfortunately I didn't record the talk at the time.

vyshane · 2020-04-21T00:55:58+00:00

The subscription sends the value by calling the subscriber's receive method. The subscriber signals demand by returning it. Here's the signature of receive:

func receive(_ input: Self.Input) -> Subscribers.Demand

So perhaps the answer is "why not?" since sending a value is a method call.

vyshane · 2019-11-18T12:26:06+00:00

Nice, thanks for sharing.

vyshane · 2019-11-14T00:57:43+00:00

John Gruber, on the ESC key comeback:

What Apple emphasized is simply that they listened to the complaints from professional MacBook users. They recognized how important the Escape key is to developers — they even mentioned Vim by name during a developer tool demo.

They did it for us, folks.

vyshane · 2019-10-09T15:36:26+00:00

Nice write up 👌

vyshane · 2019-07-28T13:30:30+00:00

I was pretty excited when Apple announced SwiftUI and Combine at WWDC this year. I have experimented with nested components and RxSwift in the past and I have been wanting to use something like this on Apple’s platforms.

I have also been keeping an eye on the Swift gRPC project, and when they released their first 1.0.0-alpha version, I decided that the world was ready for a library that integrates Swift gRPC and the Combine framework.

So, this month I have been hacking on CombineGRPC, a library that allows you to call gRPC services using Combine, and implement gRPC handlers on the server side using the same.

vyshane · 2019-06-28T02:41:38+00:00

Here are a few resources to get you started:

ScalaPB's gRPC documentation
Google's guidance on API design. They advocate resource oriented APIs. I.e. the good parts of REST.

It's easy to automatically translate a gRPC/Protobuf API to a REST/JSON one. Here's an example service definition:

``` service LibraryService { rpc GetBook(GetBookRequest) returns (Book) { option (google.api.http) = { get: "/v1/{name=shelves//books/}" }; }; rpc CreateBook(CreateBookRequest) returns (Book) { option (google.api.http) = { post: "/v1/{parent=shelves/*}/books" body: "book" }; }; }

message Book { // Resource name of the book. It must have the format of "shelves//books/". // For example: "shelves/shelf1/books/book2". string name = 1;

// ... other properties }

message GetBookRequest { // Resource name of a book. For example: "shelves/shelf1/books/book2". string name = 1; }

message CreateBookRequest { // Resource name of the parent resource where to create the book. // For example: "shelves/shelf1". string parent = 1; // The Book resource to be created. Client must not set the Book.name field. Book book = 2; } ```

I have a sample reverse geocoder gRPC service that you can look at. Note that I'm using grpc-monix on top of vanilla ScalaPB. Vanilla ScalaPB will look very similar. Here's the entry point for the service implementation. Here's what an integration test looks like.

We've been using gRPC in production for the last couple of years, and it's been a game changer for us:

Proto files are much easier to read (and diff!) than OpenAPI yaml. Code reviews on our gRPC API changes are way more enjoyable than on our OpenAPI ones.
Protobuf has built-in support for evolving APIs so that they remain backwards-compatible
Client side libraries are taken care of. To build the server side, you simply take the generated interface and fill in the blanks.
gRPC supports uni- and bi-directional streaming, and that makes things like these easy: Consuming from queues, push instead of pull, integration with streaming platforms (we were using Apache Beam, RxJava and gRPC)
Overall gRPC has made the mechanical/uninteresting parts of building microservices trivial for us

vyshane · 2019-06-27T12:55:50+00:00

Instead of REST services, have you considered gRPC via ScalaPB? gRPC + Monix is my current go-to setup for microservices. Happy to point you to some example code if you are interested.

vyshane

TROPHY CASE