Zig is small, simple, low level programming language suitable for high performance, embedded, and systems level tasks. It’s billed as a replacement to C; Which I think it is. And offers great interoperability with C. Like it’s really good. I initially became interested in learning Zig, because I kept seeing Rust compared to Zig, and I was learning Rust at the time. (A month ago). I really like Rust, but to me, Zig feels like a simpler alternative, at least on the memory management side. For the purposes I’m using it for, Writing a small embeddable programming language for the web, it’s a better choice.
Here’s some Zig code:
const std = @import("std");
const testing = std.testing;
export fn add(a: i32, b: i32) i32 {
return a + b;
}
test "basic add functionality" {
try testing.expect(add(3, 7) == 10);
}
Now what you see, is a C like syntax, with some keywords, variables, and types. Simple. i32 means a 32 bit, signed, integer. You’ll often see u8 which is a byte. function signatures are simple and expected, fn followed by the function name, some parameters, and a return value. The return values are just sittin’ at the end there. Afterwards a block is opened with a curly brace, and it’s assigned to the function. Stuff that we come to expect from these types of languages.
What made me real happy when I started learning Zig, (and earlier, Rust), is the direct inclusion of testing in the source code. I’m accustomed to seeing tests spread across a Ruby code base. Seeing them colocated with the code, at least initially, was great. Built in testing is legit.
Zig feels C like, in that C is very close to the memory. In zig, practically everything is just bytes. Each type is series of bytes put together in some way. Take a look at this:
const std = @import("std");
pub fn isAlphabetic(c: u8) bool {
return switch (c) {
'A'...'Z', 'a'...'z', '_' => true,
else => false,
};
}
test "check charater's alphabeticality." {
try testing.expect(isAlphabetic('a')); // passes
try testing.expect(isAlphabetic('G')); // passes
try testing.expect(isAlphabetic('9')); // passes
try testing.expect(isAlphabetic('*')); // fails
}
We’ve got a switch, with a series of ranges, that return true. But we’re passing a character to that switch. It’s checking the numerical value of the character, to ensure it’s within any of those ranges. Because characters are just numbers, Just bytes.
This: u8, means a byte. An unsigned 8 bit integer. In Zig you can have arbitrary bit-width integers, meaning, an integer as many bits wide as you want. u19 would be an unsigned, 19 bit integer. i5 is a signed 5 bit integer. floats can’t be arbitrarily long, we’ve got f16, f32, f64, f80, f128, and c_longdouble. Those arbitrary bit-width integers are exciting though. They make more sense when diving into unions, and making gnarly stuff.
Structs are the loose object things in Zig, and are great. They act as namespaces, kinda, and let you pack data and functions together.
const std = @import("std");
// const Self = @This();
pub const Color = enum {
red,
green,
blue,
yellow
};
const Person = struct {
name: []const u8,
age: usize,
favorite_color: Color,
pub fn init(name: []const u8, age: usize) Person {
return Person {
.name = name,
.age = age,
.favorite_color = Color.blue,
};
}
};
test "who is this?" {
const jim = Person.init("James T Kirk", 43);
try std.testing.expect(jim.age == 43); // passes
// does not compile, don't try.
try std.testing.expect(jim.name == "James T Kirk"); // does not compile.
}
What’s that note about not compiling? Well we’re trying to compare two strings. Strings are of type: []const u8, which means a constant array of u8 bytes. Because strings are just… strings of bytes. arrays of bytes. Just like in C, and in reality really. Anyways to compare them you’ll need to compare the memory of them, thankfully the Zig standard library has something we can use:
// ... abbreviated
try std.testing.expect(std.mem.eql(u8, jim.name, "James T Kirk")); // passes now.
// ...
Zig is a memory managed language. I’m not very good at those yet, but It’s memory management model thing seems pretty simple. Take a look at what I’ve got down here:
const std = @import("std");
const stdout = std.io.getStdOut().writer();
pub fn main() !void {
const name = "karl";
const status = "totalled";
try stdout.print("{s}'s car was {s}.", .{name, status});
}
Resulting in:
karl's car was totalled.
Now theres a lot here, but in that main function, you’ve got name, and status. They’re constants, so they’re not changing, and below we print some stuff out with the stdout.print thing. When the program exits all of the memory is freed. But what would happen if this wasn’t the main function? What would the memory for name and status go? Will it be freed?
Yes it will. Memory, or variables that are used like this are placed on the stack. This memory is freed at the end of each function. It’s stack memory. If you want memory to stick around, you’ll need to put it on the heap. To do that you’ll need a memory allocator.
const std = @import("std");
const stdout = std.io.getStdOut().writer();
const ArrayList = std.ArrayList;
const testing = std.testing;
// make a Card struct
const Card = struct {
name: []const u8,
suit: []const u8,
};
// Make a Cards List
const Cards = ArrayList(Card);
test "I mean whatever" {
var deck = Cards.init(testing.allocator);
defer deck.deinit();
try deck.append(Card{ .name = "Queen", .suit = "hearts", });
try deck.append(Card{ .name = "King", .suit = "hearts", });
const one = deck.pop();
const two = deck.pop();
try stdout.print("Card One is the {s} of {s}.\n", .{one.name, one.suit});
try stdout.print("Card Two is the {s} of {s}.\n", .{two.name, two.suit});
}
Ok that above is a bad example because there’s a lot going on. But let’s walk through it. First we make a card struct, it’s got two properties, or attributes. I don’t know what they’re called. They’re strings. But specifically, const strings. So their size won’t change. Then we call the ArrayList Function. This makes a type and returns it. The type is a growing, heap allocated, array. It’s typed, and we supply it a type of Card. So we end up with Cards. I very much like this.
Now, it’s this allocator thing that actually does the allocation of memory. It grabs some memory on the heap, and gives you back an ArrayList that you can put stuff into. append() inserts Card structs into the ArrayList. We can pop those values and use them below in the print statements. But putting this all in a single test seems silly, let’s have a helper function.
const std = @import("std");
const stdout = std.io.getStdOut().writer();
const ArrayList = std.ArrayList;
const Allocator = std.mem.Allocator;
const testing = std.testing;
const Card = struct { name: []const u8, suit: []const u8, };
const Cards = ArrayList(Card);
// returns a deck of cards
pub fn makeDeck(allocator: Allocator) !Cards {
var deck = Cards.init(allocator);
try deck.append(Card{ .name = "Queen", .suit = "hearts", });
try deck.append(Card{ .name = "King", .suit = "hearts", });
return deck;
}
test "I mean whatever" {
var deck = try makeDeck(testing.allocator);
defer deck.deinit();
const one = deck.pop();
const two = deck.pop();
try stdout.print("Card One is the {s} of {s}.\n", .{one.name, one.suit});
try stdout.print("Card Two is the {s} of {s}.\n", .{two.name, two.suit});
}
In this new example, we give makeDeck an allocator, and it gives us back a deck with some heap allocated memory. Notice the return value: !Cards, that means that, possibly, it could fail. That’s why we’re putting try everywhere. (Try/Catch works differently in Zig.).
Once we get our deck back we can play around with it and print our stuff.
Now try removing the line: defer deck.deinit();. If you do, and you run some tests: zig test deck.zig, then you’ll see a whole bunch of debug output, and at the bottom the messages:
All 1 tests passed.
1 errors were logged.
1 tests leaked memory.
It’s catching our leaked memory! Why? because when you use an allocator it puts memory on the heap, not the stack. So the variables and data you make don’t get freed at the end of the block. They stick around. It’s up to you to free them later.
Zig has this thing called defer which defers an action until the end of a block.
const std = @import("std");
const testing = std.testing;
const print = std.debug.print;
test "I mean whatever" {
var count: usize = 0;
count += 1;
print("count is:{d}\n", .{count});
count += 1;
defer {
print("count is:{d}\n", .{count});
}
defer count += 1;
defer count += 1;
print("count is:{d}\n", .{count});
}
defer blocks are executed in reverse order. Which is actually fantastic. Oftentimes you build up some heap allocated state from top to bottom, but as you go down you get deeper and deeper into the state of some more complicated data structures. With defer you can pair allocations with deinit(), and unwind that state, and free that memory.
I can talk a lot more about this. Like about slices, and how they are easier to work with than arrays. Or that strings are just arrays and working with them is easier when they are slices. But I’ll get into that later when I describe more of the internals of Mage and Kona which will be written in Zig.
Talk to you soon.
-kow
]]>If I was going a little slower, or a little faster, we would be dead. The collision happened towards the aft of my vehicle, just ahead of the left rear tire. The conflicting vectors of the colliding vehicle, and our own, caused our vehicle to spin 200 degrees counter clockwise and land with a calm jerk and a slight startle. Indeed this motion swung my car’s big ass around, and swiped off the front bumper of another vehicle just sittin’ there. But the spinning motion itself dissipated the momentum, and diffused the kinetic energy. Nobody was injured beyond a bump, or scrape, and an inconvenience. The cars looked like paper maché models partially desiccated by a toddler.
Some folks would say: “how lucky, that our modern cars are so safe to render a collision like this no big deal”. But I am not that man.
Cars are Aluminum coffins, death machines we’re forced to enter, at the danger of never leaving them, because of the inconvenient and vast world we’ve constructed that require them. Car culture is Violence. It turns everyone into a deadly enemy, and routine, into danger. I fucking hate driving.
The vehicle we immediately collided with held a mother and two small children, they exited the vehicle, unscathed but shaken. Still clutching their new, colorful toy guns. Harmless specters of America’s other deadly obsession, Firearms. Ironic. Poetic. Often, My own son, three years old, sings: “A B C D E F GUN!”. A grim innocence that we allow. We hasten to instruct, that actual weapons make us all unsafe.
My initial reaction, upon collision, was of immediate relief, neither fear nor surprise. I saw the near fatality less than two seconds before impact. A narrow window, closing, was before the car crossing the intersection. I reasoned the safest place for me to go, would be into that spot, where there was space to dissipate the kinetic energy. I truly didn’t realize until later how close I was to serious injury or death. A moment of haste or hesitation and it would be over. That’s all she wrote. Fin.
I checked on my only passenger, my wife, safe, unscathed. Myself, unscathed. Then hopped out of the car and immediately checked on the others affected. Everyone safe and unharmed. Now financial and time inconvenience is all that remains.
As I mentioned earlier. The collision was precipitated by a city wide power outage. In fact, as the fireman and paramedics that quickly attended us said, fire alarms across the city had been going off because of the outage. The police said that this same intersection had already lost power, and been restored only moments before. The arrival of first responders felt eerily quick. A handful of seconds and they were there. I didn’t imagine it. They were already on their way, unaware as to what danger could be found, but finding it almost instantly.
My wife has become rather good at fitness, she wears an Apple Watch. And that thing immediately called the cops. It knew we crashed, a prescient message on the screen: “It looks like you’ve been in a crash.”. Yes. I know.
There is a clear and stark division between knowing ABOUT something, hypothetically, and understand and mitigating those risks. Quite another to understand intimately the danger by narrowly escaping death in one of these death machines. That’s experience. Having crossed that division at 37 years old in a near fatal incident, my calm exhortations to be safe, careful, and suspicious, are now haunted by the sound of death’s scythe cutting through the air just ahead of me. A near miss.
I’m tired. Very mildly shaken. But mostly Angry. I don’t have time to handle the inconvenience of another tragedy. I attempt to make Stability and Reliability my reputation. A struggle. Now further complicated by this messy thing we call life. On Monday I start a new job, my family is safe, and I have a warm place to sleep. Trauma, some new hidden scars, but nothing beyond what life promises. Which is just life.
-kow
]]>Yes I use iPhones, so I should be able to find it, right?. The conversation quickly went to why he killed himself. They don’t know, maybe he was depressed or sad. No signs of mental distress. My Dad said it’s everyone’s choice what they do. That’s true, but it’s also a choice to make Guns so readily available in America that anyone can have one. “It’s their right to have one”. Sure, but this is the result, He’s dead. “No but it was his choice to kill himself”. A choice that would be so fucking hard to carry out if he didn’t have a fucking gun where you just pull the trigger and something dies.
I got mad at him, because I like my dad and he’s pretty reasonable. But this Gun shit pisses me off. Because Our rights and the Law and the rules are all made up. We make them up. And when we have rules and laws and a culture to follow them, things happen. We create an environment. Right now we have an environment in America where gun deaths are easy to come by. Suicide is easy, Mass Shootings are easy, and School Shootings are easy. You want your rights, sure, have your guns, but this is the result.
America wants mass suicide and school shootings. That’s the purpose of these laws. The purpose of a system is what it does. It’s a fucking fact. Our system kills people. That is the design.
I feel really sad for my sister. But I can’t mourn or be gentle or careful because we rarely speak. I don’t know him very well at all, there’s no emotional sadness. I’m not gonna fake that. I am fucking enraged though. So mad that it can be so clear why something happened, and the people that you used to look up to and turn to for advice and wisdom, will say reductive defeated things to explain away why someone killed themselves.
The difference between a bad day and his last day, was a gun.
I don’t know if you’ve been reading the news lately, but in America, there’s mass deportations going on. Or at least the attempt of it. The mass dissolution of our rights, and our institutions. The looting of our public works and sensitive data. The robber barons have returned in force and are taking everything they can get their hands on. But we don’t have to cede anything to them, or accept it, or do nothing.
I’m enraged because a Coup is genuinely being carried out in my country in broad daylight, but we are culturally bound from doing anything because our entire society is built around respecting capital. The rich are smart, the masses dumb. They are skilled, we are not. The police protect the property of the wealthy, while trampling the rights and well being of everyone else. Which is everyone. I’m fucking mad because I NEED to work, and provide for my family, and pay off a shit ton of debt, when I also NEED to be organizing and educating. Beating the doors of my neighbors down, and demanding that they bear witness to the wholesale destruction of what we take for granted.
We are not powerless, or outnumbered. I will not succumb to fear, nor will I become overwhelmed and allow my joy and focus to wander and be ruined. I’ve learned that in America nobody is coming to save you, you have to save yourself.
Nobody is coming to save us, we have to save ourselves.
Nothing will get better unless we MAKE it better.
I’ll tell you what I’m going to do. I’m going to organize. Double down on my studies of Spanish, economics, and our political system. I’ll spread as much literature and knowledge of our rights in this country as I can, with the time that I have. I won’t stand a racist shit to persist in my presence without making them feel unwelcome, and ashamed. I’m also gonna get jacked as fuck.
I don’t give a fuck about debating or reasoning with the shitheads. That’s not how you change things. You force change. You change the culture, what’s accepted, and what’s not acceptable by making a stand. Over and Over and Over again. You give the people, the majority, the tools to know what their capable of, and the courage to wield their power. We are all in this together, not one of us are alone.
If you want a better world, make one.
I’m gonna fucking make one.
-kow
]]>I often find myself stretched thin, breaking the money or time systems. Not enough money, not enough time. In a capitalist society, the two are tightly connected. My Money system doesn’t have enough slack. I have a budget. I usually keep within spending limits. But it’s that lack of slack that breaks things. The 3 birthday’s in a row in the same month, or the unexpected bill. Living within a budget becomes harder and harder every day. Having a robust money “system” just means having more money. A buffer, a cache, a cushion.
Time is the same way, although it feels like it operates more like trains do. I have responsibilities, promises that I’ve made. Fulfilling a promise, or keeping my word takes up a certain amount of time. Work takes time. If a task or project takes a little more time than anticipated, then I have to “borrow” that time from somewhere. Sleep? Family? Fun? The next Promise? Other systems. Other commitments. All systems run on time, and running out of time is no fun. Like trains crashing. A Wreck.
My career is engineering, programming, and design. Estimates are always a little fuzzy. Oftentimes I’m asked to do things, or solve problems I’ve never faced before. To offer my perspective and expertise in delivering solutions, but towards unfamiliar concerns. The estimations always start the same, sus out what’s familiar, and what’s not. Allot time, based on past experience, provide a buffer. Later, during the act, the true requirements present themselves. Well laid plans change, time scales slip. It’s in that buffer that I find respite and rescue. A saving, bonus zone of attention and energy to overcome the unexpected.
The only way I’ve found to relieve stress, in many senses of that word, is to have more slack in my systems. Under schedule, under promise, over deliver, deliver early, spend less, budget more. I now plan 3 or 4 days of actual work. It means choosing to do far far less than I’m honestly capable, to make certain every train runs on time, and every promise is fulfilled. Putting slack back into the system of my life. My daily efforts to survive, provide, breath, and live.
Leave more time to make mistakes, and recover from them. To do nothing, think of nothing, and expect nothing. Sit with yourself a bit longer.
It’s incredibly difficult, I feel like I’m getting better at it though.
-kow
]]>New year, new design. This is my new website for 2025. Hopefully for far beyond this year too.
It’s designed more minimialistic than past experiments. I’ve gotten a lot better with CSS Grid. Which is Over powered. I also have a fun little idea about adding grunge and graffiti to the blog, as if it was some wall somewhere, arbitrarily. Like covering text, and images in silly ways. I think it will be fun. Also it gives me a recurring outlet for small pieces of Art. Like for fun. Just hacking away on my website when I’m bored, vandalizing it.
I’m gonna vandalize this web page.
-kow
]]>A while ago I declared online that I really really hated Javascript. Lately, I still don’t like it, but my hate just doesn’t seem to go as deep. Then I declared that I would replace it with something better. In that pursuit I began working on my own language, named Kona. Intended to be compiled to WASM, and shipped in your browser like a 200KB party favor.
Kona isn’t ready yet. In fact I’ve barely begun the compiler/interpreter/VM. The thing about writing a programming language is that you need to know how to do that. If you don’t know how to do that, well… then you can’t do it. So I decided to learn.
I began by reading the book Crafting Interpreters, which is absolutely excellent. But before I could finish I needed to go learn C, A language I had never written. Then I went and I learned Lua, Thinking I could write all of Kona, in Lua, and ship it as a single binary. I got pretty far there, and learned a lot. But then I stumbled upon Wren, a small, object oriented language written by Robert Nystrom the author behind crafting interpreters.
I was immediately intrigued. It’s a small, fast scripting language. comparable in speed to Lua, But with a heavily simplified object oriented syntax. Purpose built to be embedded in other applications, like Lua, but with a simpler API.
The best thing about this language, is how EASY it is to learn it’s internals. Volumes of comments and descriptions populate the source code, making it easy to poke around and understand how it all works. In my pursuit of writing Kona, it was never my intention of building the whole thing from scratch. I mean, I want to Finish the project after all. I was content to start by writing Kona’s interpreter in Lua, then learning C and porting it to that. Now I’m emboldened to write Kona’s compiler in C, and target Wren’s VM, initially, To execute the code.
Anyways, to actually ship the project I want the project to be much smaller than fully a new language. Targeting a VM with unique syntax seems like a good tradeoff. Although, as I go along, I know I’ll find myself making those changes, and writing my own unique VM.
I should explain how we get a new language at all.
Computer processors each have their own dialect of instructions. x86, RISC-V, ARM, etc… Learning to write programs for each specific architecture is arduous. So some smart folks decided that they would write a program that would transform simpler instructions, into the specific instructions of a processor. A compiler.
Compilers have quite a few parts, but the top most part, called the front end, scans code in it’s particular syntax, and translates it into tokens. String, Number, Name, Operator. Then takes these tokens and translates them into the machine code of whatever computer your targeting. There are other concepts that are captured too, like scope, and upvalues, etc..
Scripting languages are a bit different. Instead of compiling the code to native machine code, scripting languages compile your code into an intermediate, but internally represented Byte Code. The scripting language then runs the byte code through it’s Virtual Machine or VM, and executes the program accordingly.
The journey to get from your code, to tokens, to byte code, and then finally to be executed, offers a host of benefits or disadvantages, depending on your choice of language. New languages are made every day, or existing ones are improved. All in the pursuit to make certain tasks easier.
Consider this code:
class Person {
name { _name }
construct new(name) { _name = name }
}
var jim = Person.new("Jimmy")
// > jim
System.print(jim.name)
// > Jimmy
We have words, symbols, spaces, curly braces, all sorts of stuff. Along with a litany of rules and practices you’ll just need to learn about the language. All in the pursuit to make our lives a bit easier. These rules and how it influences the way you write your programs, the syntax, determines what’s easy, what’s possible, and what’s enjoyable. That is the sweet spot I’m trying to pursue.
The parser takes source code and converts it to tokens. Consider this:
var thing = "whatever"
Which, when parsed, produces the following tokens:
[ VARIABLE] => var 0..2
[ NAME] => thing 4..8
[ASSIGNMENT] => = 10..10
[ STRING] => whatever 12..21
Now, Wren’s compiler is a one-pass compiler. That means these intermediate tokens are never really created, and Byte Code is emitted directly. Wren’s compiler has a single token look-ahead, look-behind, So it only really knows what’s immediately ahead and behind a token. This severely limits certain syntax possibilities, but in turn, it makes the parser very simple.
Consider this structure:
class Nuts {
go { _nuts }
go=(v) { _nuts = v }
construct new() {}
}
We define a class, using a keyword class, and add some setters, getters, and a constructor. In wren, the method signature is part of it’s name, and all properties, called fields, are private, so you need to add setters and getters.
Instead of marking the methods with def or func or something else, they are simply Naked names with blocks after them. name + block is a simple pattern for making a method. Now let’s call some methods:
var nutty = Nuts.new()
nutty.go
// > null
nutty.go = "Nuts!"
nutty.go
// > Nuts!
Here we show some more goodies. A var keyword to tell the compiler that nutty is a new variable. The compiler emits bytecode to create that space, and then later it’s assigned. Because the Wren compiler is a single pass, with only limited look ahead, we need to emit these tokens:
[ VARIABLE] => var 0..2
[ NAME] => nutty 4..8
[ ASSIGNMENT] => = 10..10
[ CLASS] => Nuts 12..15
[ DOT] => . 16..16
[ NAME] => new 17..19
[ LEFT_PAREN] => ( 20..20
[RIGHT_PAERN] => ) 21..21
Now whitespace is usually ignored, so we don’t add those, but we do want to know what each token is. You can tell from the first token and the second, that a VARIABLE declaration immediately followed by a NAME. This means that we want to set aside some storage. The bytecode to do that is then emitted. The next token is ASSIGNMENT, a binary operator. It takes the next STATEMENT, and assigns it to the name that came before. At this point we know that what comes next needs to be a valid statement, so the compiler begins interpreting the next tokens assuming this. If it runs into an unexpected situation, it can emit an error.
It may not seem immediately recognizable, but a single pass compiler means that certain features just aren’t feasible, or pretty difficult. Additionally, to keep the syntax simple, certain other features are not as easy. Consider free floating functions:
myFunction()
In an object oriented language like Wren, we have a name token, and an opening and closing paren token. The name is resolved at runtime, and the following tokens become part of the name to make an invocation. But what is it being invoked on? In Wren the parameter list, or at least it’s arity, are part of a methods signature, so a free floating function, as an object, would have to be implicitly called against this, like other naked methods are. But what is this? If you call myFunction() inside of a method in a class or outside in a free space what is the value of this? It’s different in each situation.
This is where the design of the language and it’s syntax begin to have consequences. What do we want to make easy in a language? And what are the consequences for making something easy.
Anyways. I really like Wren, and I’m excited to see where that language goes. It is a bit restricted from what I’d like to do. Classes can’t be reopened, method and function calling is explicit, which is nice, but restricts certain patterns. The compiler is single pass which means that complicated features like optional parens are not feasible.
Kona is intended for building UIs and interfaces on the web. A general purpose programming language, sure, but focused on a single platform. That focus means that syntax limitations, and in effect the design of the language, needs to be reconsidered at every step. i’m aiming for a multi-pass compiler to give some more complicated syntax features. Built in JSON, and HTML parsing. Built in HTML templates, Builders, class reopening, functions as first class citizens, and object tree diffing.
The target is the web, a Programming language VM as a WASM module that listens to and interacts with the webpage through the available APIs. We’ll see how far I get.
-kow
]]>America has shifted to be more Fascist, Racist, and Misogynistic than I hoped. I was hoping for not that.
I’m not depressed. Or Sad. A little Angry maybe.
Being led by the mediocre is the price of Apathy.
Building a better world means fucking building it. Doing the work, whatever that is. And taking others along the way with you. That’s what I plan on doing.
-kow
]]>It’s me, Karl,
I’ve just been feeling incredibly depressed and burnt out lately. Some things happened at work that were not completely in my control, and some other things that were in my control and I just really failed. I think My EGO has been hit and beat up. I’m unmotivated every day. I’m not sleeping well. I’m barely getting my current work done. I have looming deadlines that are still far off, that I want to hit early, but now I feel like I’m gonna come in just before the wire. Just before they are due.
When I was younger in my career I would get really depressed when I couldn’t deliver something at work. I would feel like a complete failure, that at any moment I should be fired and just jettisoned. Hindsight has provided perspective, that I was too hard on myself. A good environment is a safe environment where we can learn and grow. Make mistakes and improve. Capitalism prompts a pressure to deliver. If we don’t, we could lose our jobs and shit can hit the fan.
I’ve lived with that pressure more than most, I think. At least far more than other folks I know in the industry. Which is a bummer. Constant fight or flight mode does not a healthy person make. I’ve talked before about the stresses of being laid off and trying to build a new business as fast as possible. It’s very hard, with lots of failure mixed in.
I don’t know. I’m just thinking: How do I get really stable and reliable again without fucking up? Without pushing myself to the breaking point? Folks are depending on me and I wanna deliver.
I haven’t even talked about my family and kiddos. I’ve sacrificed so much time and attention with them for my career to still end up at, like…. the bottom? I can’t just work way more to make things better and ignore them anymore.
Honestly this whole experience has made me want to have less responsibility, expenses, and worries. Just less of everything, but more time. More time to rest, be healthy, be with my family while they are still really little. If I’m really broke, but calm and dependable, that’s a good trade off for me.
I’m gonna do a lot less from now on, but just deliver. I think I need to slow down.
-kow
]]>What a relief.
Starting over new, and fresh, and shiny, seems like a lot of fun. Keeping things simple also seems like a lot of fun. My last website ran on Ghost, which is fine. It’s good. It’s Great. But there were drawbacks. Like the necessity to have a runtime to get it to… Run. Every attempt I had to make a dynamic experience that required a server with log ins, and a web editor, failed. It was a pile of unnecessary. There’s nothing dynamic here. I can write HTML and CSS myself I don’t need a server. I don’t need logins
I hope to have a server that needs all that again. Truly, But ever since going freelance again I’ve been making more websites in less time than I ever have. Piles and Piles of HTML and CSS. I’ve got these muscles loosey goosey. I’m Dialed in. Focusing on my craft.
I ripped off the feeling of this blog from A nike design book and the old Nasa style guide from the sixties. There’s something fresh and clean about a san serif typeface that looks a little too much like Helvetica. The typeface is General Sans, a favorite of mine. It’s clean, bold, and has a punch of personality. Most importantly it’s a bit weightier in the mid weights just like I like it. I’m not fond of a medium or regular font weight that feels too light. Give me meat on them bezier curves.
I wanted to challenge myself a little, and also actually ship a project quickly, so I followed a few rules.
I also decided to Use Jekyll. I gutted it, and dropped my stuff right on into the joint. Works great. Also works with RSS too. I actually wanted to use Camping, but it’s not ready yet. But that will change this summer. It’s been moving along at a steady pace, needs some database love, and a some deployment love, and it’s golden.
To fulfill these development requirements the design also had to be more streamlined and focused. I went with a two column layout, split down the middle. Everything is split on that axis. Narrow screen sizes are just stacked vertically. You know, the classics.
Repurposing typography decisions and only minimally making some changes. This means that Blog post previews, the little cards, only require a few styles to get it to behave like a card. The text just works inside because I did a good job. Only two Heading types are used to keep it simple too. h1, h2, that’s it. A couple of page headings get some love to adjust their top margins in certain contexts, like on the home page.
Instead of having special layouts for each page, I make a layout context using CSS Grid. Then setting that on a container by using a custom attribute:
main[layout="home"] {
display:grid;
grid-template-columns:1fr 1fr;
grid-template-rows: auto;
grid-template-areas: "left right";
column-gap: var(--space-l);
row-gap: 0;
}<main layout="home" aria-label="Content">
{{ content }}
</main>This makes a two column grid with equal width for both sides. I put it in a vertical column when things get too small:
@media (max-width: 800px) {
main[layout="home"] {
grid-template-columns:1fr;
grid-template-areas: "left left" "right right";
row-gap: var(--space-l);
}
}I’ve tried to push things to be incredibly simple, with a little style on this build. I think I’ve achieved it. I hit all my goals. Looks nice, Shipped fast, Nothing broken.
All in all it turned out alright.
-kow
]]>_posts directory. Go ahead and edit it and re-build the site to see your changes. You can rebuild the site in many different ways, but the most common way is to run jekyll serve, which launches a web server and auto-regenerates your site when a file is updated.
Jekyll requires blog post files to be named according to the following format:
YEAR-MONTH-DAY-title.MARKUP
Where YEAR is a four-digit number, MONTH and DAY are both two-digit numbers, and MARKUP is the file extension representing the format used in the file. After that, include the necessary front matter. Take a look at the source for this post to get an idea about how it works.
Jekyll also offers powerful support for code snippets:
def print_hi(name)
puts "Hi, #{name}"
end
print_hi('Tom')
#=> prints 'Hi, Tom' to STDOUT.
Check out the Jekyll docs for more info on how to get the most out of Jekyll. File all bugs/feature requests at Jekyll’s GitHub repo. If you have questions, you can ask them on Jekyll Talk.
]]>