205 karma · joined January 25, 2017
Communication encouraged! I enjoy talking to people. Feel free to send me an email.
email: badtuple@the.sarl
everything else: badtupleReally hard things I _could_ do on stream...but I start to feel like it's too much of me staring really hard silently. I have to wonder how much of that is true and how much of that is personal anxiety. I do enjoy streaming though and should do it more.
var el = document.querySelectorAll('*');
for(var i=0;i<el.length;i++){
el[i].style.backgroundColor = '#FFF';
el[i].style.color = '#000';
}
If you don't mind sharing, why does it make you physically ill? I've heard of people not liking it, but this is the first I've heard of an actual medical issue and I'd like to be aware of it when designing things.The suburbs can't escape cars, but I bet we can make Portland proper a utopia for pedestrians.
I already barely use cars. It's wonderful compared to Orlando (where I happened to grow up).
When the big one does hit though, there's definitely a long list of people who are going to be totally entitled to a good "I told you so".
I did the nomad thing for a couple years and loved it, but I sort of got it out of my system. The lifestyle can be lonely. And at this point in my life I'd rather cultivate a life of my own instead of running around enjoying little bits of life elsewhere. Not that I wouldn't take advantage of the ability to travel much more freely!
Consuming gives you new ideas on what to produce and enthusiasm about what you could create. You can't produce without consuming, and you likely won't be satisfied just consuming indefinitely.
I'd be really interested to hear experiences of people who have done it though, even as a toy.
The concept is that you can push Messages to an append only log, but can only query them back out via Iterators. An Iterator is a map, filter, or reduce function that iterates over either a Log or another Iterator.
Iterators can be composed and optionally persisted. So the data can be transformed at query time, or persisted and just read from disk. Iterators allow you to start at an arbitrary message, so it can be used as a persisted message queue or similar.
I'm only a few commits in, and there isn't much to see yet. I'm really excited by the power and simplicity of the idea, and to have a lightweight Kafka alternative. Feel free to follow along if interested: https://github.com/badtuple/remits . If you feel like working on something in Rust, feel free to reach out on Github issues or email. It's always fun working with other people.
This. But it doesn't have to be accusatory like that. It's a way to have opportunity for feedback without having to be pressed for feedback.
The best manager I ever had was great because he totally trusted his people. Standups were a non-intrusive way to keep the overall pulse and make himself available if he was needed...that way he didn't need to vulture around to make sure he could insert himself if needed.
I'll take planned and well used 5 minutes of direct management over compulsive and nervous micromanaging anyday.
I'm super interested in symbols as a way of increasing expressivity, but the ctrl+cmd+space route just seems like it'd be too much overhead for the tradeoff to be worth it.
I'd love to hear what people who have gotten over the learning curve think about it as a language feature.
I read the post and all the comments here, where people are very adamant about their opinions on parens. It seems to me that while syntax is important, parens in this context is about as close to "just syntax" as we can get. Racket-sans-parens would still be Racket.
Am I missing something fundamental?
I've used Go professionally for 6 years and love it, so the patterns are ingrained in my head and don't bother me. But it seems pretty clear that it's much more arcane than alternatives.
The number of times I redo the same thing in a repl or with weird scripts saved in /tmp or ~/ is kind of nuts....but generalizing them into something like this takes tons of work. Kudos!
{
"hello": {"{{place}}":{{{#items}}"{{thing}}":{{n}},{{/items}}}},
"urls": [{{#items}}"{{url}}",{{/items}}]
}
It's unambigious and can be reasoned through, but it's certainly hard to tell what structure the template is building at a glance. This is not a complex or contrived example.Syntax highlighting, linters, proper indentation, etc. all help...but when talking about non-programmers who aren't used to this it's an incredible hurdle. People are also lazy and error prone, so you can't rely on indentation to make things clear, especially since it's not always clear how you should indent nesting of the template vs nesting of the json datastructure you're trying to build.
Most modern templating languages have a config option for changing the delimeter. Setting it to something like (( or << might help differentiate things a bit, but then you're throwing away easy use of examples, documentation, stack overflow questions, and so much more that already exists for that language. That documentation and copy-pastable community help is not something to throw away lightly if you're designing a tool for this audience.
It's also worth pointing out that the above template generates subtly incorrect json with trailing commas. In pure mustache it's not possible to get rid of that trailing comma. You have to either change your data (add a "last":true key to the last element of any arrays), or have some kind of post-processing step.
All of the existing solutions are workable, they just aren't ideal.
Tools like Zapier, Customer.io's webhooks, etc. allow integration with arbitrary APIs and have become a standard part of many marketing/sales stacks. These apps use things like Jinja, Mustache, or Liquid which are great for text but not JSON templates.
Curly braces as primary delimiters, not allowing trailing commas on final elements, and other features of JSON make generating it a real hassle.
Jsonnet is too complex to be that tool, but I'm glad people are working in the space.
- Encounter a status code in some code
- Go to https://statuses.now.sh/
- Type in the status code
- Read the explanation
That's 66% of the steps. It's harder to remember that URL than wikipedia though. You could remove a step if you could easily put the number in the url without having to remember the "code" query param. Just go directly to https://statuses.now.sh/418.
I live in the terminal. If I'm investigating a status code then I have a terminal open. That's not true for everyone, but it'd be super cool if I could `curl https://statuses.now.sh/418` and get plaintext information about the status right from my terminal! You could implement that by checking the user agent to see if it's curl/postman/etc.. or requiring a .json or .txt extension at the end. Either way, it'd cut my workflow down to three steps:
- Encounter a status code in some code
- `curl https://statuses.now.sh/418`
- Read the explanation.
It also allows me to set an alias/function in my bashrc so that I don't have to remember the url.
As for the svelte part, I haven't used it and don't really do frontend dev very often...but I bet you'd get more specific feedback on the code itself if you listed a git repo people could use to check things out.
To those trying it out: if the diagram seems inaccurate, try dragging tables around.
I uploaded a very simple schema, but seemingly unrelated tables looked connected. Turns out it's 100% accurate, but relationships can run behind other tables and make it look like things are connected that aren't. Detangling is easy with a few drags/drops and you get a really nice diagram out of it.
As the project progresses you'll get more context on why things are what they are than is explicitly written. Eventually you'll hit on something that actually is better and now you're a what-the-article-teaches developer!
Just downloaded the app and it's awesome. Thanks for making it!