recentpopularlog in
« earlier  
GitHub - mxcl/swift-sh: Easily import third-party dependencies in your Swift scripts
Easily import third-party dependencies in your Swift scripts

Just import a dependency and annotate some metadata (version, location, etc.), and the execute your program under the hood with `swift run`.

This is how all third-party dependency management should work :) Just declare the dependency import in source, and move on; no package or declaration or manifest files.
homebrew  via:twitter  swift_lang  cli  dependency_management  scripting  is:repo  swift 
4 weeks ago
Unplugged: what I learned by logging off and reading 12 books in a week | Books | The Guardian
Perhaps it’s not surprising that, in the context of a perfectly designed reading experience, it was easy to avoid distraction. But too many of the arguments about social media “addiction” pay no attention to context when they should. Many of the ostensibly “addicted” social media users are always working, trapped at our desks or in our cars, eyeing our phones, perpetually on call. Like coffee, the little dopamine hits of a “like” or “fave” are an affordable pleasure in a world of constant work.
books  deep_work  concentration  social_media  work  life 
6 weeks ago
GitHub - fabiospampinato/notable: The markdown-based note-taking app that doesn't suck.
A seriously impressive looking Markdown-based notes app with file attachments.
markdown  notes  apps  electron  tool 
6 weeks ago
No More Oppatoo
This one hit a little too close to home :)
In a flash, the behaviors, quirks, and tiny things you’ve grown to love disappear. Just like that, they’re replaced by new phrases, new quirks. New things you’ll also grow to love – before they disappear too.

It’s beautiful, and it’s great. But it also hurts your heart a little bit.

So we take photos, and now videos. And we indulge our hearts, and cry a bit. Sometimes from pride, sometimes from joy, and on occasion from the loss of something tiny.

And when we see a new parent, one with a child much younger than ours, we know it’s silly, but we can’t help ourselves. We feel it’s very important to let them know:

“Enjoy it while it lasts. It goes by faster than you think.”
6 weeks ago
restic/restic: Fast, secure, efficient backup program
Seems like a decent, open, cross-platform alternative to Arq/Backblaze/home-rolled backups:
restic is a backup program that is fast, efficient and secure. It supports the three major operating systems (Linux, macOS, Windows) and a few smaller ones (FreeBSD, OpenBSD).

Restic is a program that does backups right and was designed with the following principles in mind:

• Easy: Doing backups should be a frictionless process, otherwise you might be tempted to skip it. Restic should be easy to configure and use, so that, in the event of a data loss, you can just restore it. Likewise, restoring data should not be complicated.

• Fast: Backing up your data with restic should only be limited by your network or hard disk bandwidth so that you can backup your files every day. Nobody does backups if it takes too much time. Restoring backups should only transfer data that is needed for the files that are to be restored, so that this process is also fast.

• Verifiable: Much more important than backup is restore, so restic enables you to easily verify that all data can be restored.
Secure: Restic uses cryptography to guarantee confidentiality and integrity of your data. The location the backup data is stored is assumed not to be a trusted environment (e.g. a shared space where others like system administrators are able to access your backups). Restic is built to secure your data against such attackers.

• Efficient: With the growth of data, additional snapshots should only take the storage of the actual increment. Even more, duplicate data should be de-duplicated before it is actually written to the storage back end to save precious backup space.

Some write-ups on using restic:
tool  backup  is:repo  software  rsync  arq 
6 weeks ago
AnyCable: Action Cable on steroids!
Polyglot replacement for Ruby WebSocket servers with Action Cable protocol

websocket  ruby  golang  rails  rubyonrails  ActionCable  erlang 
6 weeks ago
Will S / chorded_keymap · GitLab
This project is inspired by the Simultaneous Vi Mode for Karabiner, a keyboard mapping extension for macOS.
Because of architecture changes introduced in the Sierra version of macOS, Simultaneous Vi Mode does not work in Karabiner on the latest versions of macOS (see here).
Another related macOS project is Jason Rudolph's keyboard project which used Karabiner's Simultaneous Vi Mode in the past and now uses an alternative implementation.

Similar functionality has not been easily accessible on Linux. The closest there has been is the Plover stenography project. While it may have been possible to work from Plover to implement Chorded Keymap, this approach was not followed because Plover relies on the X display server to capture keyboard input and most Linux desktop environments are moving towards implementing the Wayland protocol in which applications and device input are more strongly isolated.
Interception Tools operates at the libevdev level, just above the kernel before keyboard events are processed by higher level abstractions like libinput, xkbcommon, or the window manager of a graphical desktop.
Working at this low level allows Interception Tools to work under many different systems, but it means that the state of the keyboard must tracked within Chorded Keymap.
is:repo  linux  keyboard  hack 
6 weeks ago
Our World in Data
Explore the ongoing history of human civilization at the broadest level, through research and data visualization.
data  statistics  visualization  history  economics 
7 weeks ago
The Complexity Trap: Think Before You Leap - Daniel Westheide
imagine the unthinkable for a minute: What if we did server-side rendering of HTML instead? There wouldn’t be any need to design an evolvable JSON API, which, unlike simply exposing your domain model, is not trivial, and there would definitely be no need for defining any JSON codecs. And that’s just what you get on the server side. On the frontend side, you would have one piece of software less to maintain, you’d get faster load times and you could get rid of duplicated business logic. To sum it up, you could reduce the complexity of your frontend JavaScript code a lot.

In the words of Jorge Manrubia, who wrote a great article about how the complexity introduced by single-page applications can often be entirely avoided: “[..] what about if, instead of trying to find a solution, you put yourself in a situation where those problems don’t exist?” Eliminating problems altogether is always better than writing code to solve them, regardless of how purely functional that could is.

But why is it that we fall for technological solutions so often, especially ones that don’t reduce complexity at all? I think that maybe we love progrmaming too much. I was recently talking to someone about Rust, and that person said, “A language without higher-kinded types is completely useless!”. Yes, certain abstractions are not possible without them, but I have never seen a project fail due to a lack of higher-kinded types. Projects fail because the problem domain is not well understood, or because the architecture is not a good fit for the requirements. They also fail because of how the organisation is structured and because of politics, be it intra- or inter-organizational. Projects fail because of people, and because of people not talking to each other.
programming  complexity  team  bestpractices  spa  client-side  team_management  javascript 
9 weeks ago
An application [written in Crystal] for local searching of CVE data.
crystal_lang  cve  database  is:repo 
12 weeks ago
Tweet by Ryan Singer @rjs
Tech shouldn’t be downstream from design, and design shouldn’t be downstream from tech. You need both together from the beginning to have a viable concept. Then they take turns.
design  development  engineering  is:tweet 
12 weeks ago
Fundamental attribution error - Wikipedia
Fundamental attribution error (FAE) […] is the concept that, in contrast to interpretations of their own behavior, people tend to (unduly) emphasize the agent's internal characteristics (character or intention), rather than external factors, in explaining other people's behavior. This effect has been described as "the tendency to believe that what people do reflects who they are".
The classic example is driving in traffic: a driver that cuts you off is a jerk, but if you cut a driver off it is because you are rushing to the emergency room.
cognitive_bias  psychology  cognition 
september 2018
cgarciae/pypeln: Concurrent data pipelines made easy

Pypeline is a simple yet powerful python library for creating concurrent data pipelines.

- Pypeline was designed to solve simple medium data tasks that require concurrency and parallelism but where using frameworks like Spark or Dask feel exaggerated or unnatural.
- Pypeline exposes an easy to use, familiar, functional API.
- Pypeline enables you to build pipelines using Processes, Threads and asyncio.Tasks via the exact same API.
- Pypeline allows you to have control over the memory and cpu resources used at each stage of your pipeline.
via:flav  is:repo  data  data_engineering  python  data_pipeline  big_data  async 
september 2018
dry-rb is a collection of next-generation Ruby libraries
dry-rb helps you write clear, flexible, and more maintainable Ruby code. Each dry-rb gem fulfils a common task, and together they make a powerful platform for any kind of Ruby application.
ruby  functionalprogramming  monad 
september 2018
Google Chrome UI – Figma
A Figma recreation of the Google Chrome browser chrome; helpful for placing mockups more in situ.
design  figma  template  tool 
september 2018
Figma's Engineering Values
Direct image:

1. Communicate early and often
- Don't wait until code review to share your direction
- Solving something together is better than solving it independently
- Assume best intentions when receiving feedback

2. Prioritize impact
- We can only solve so many problems at once, so pick your battles
- Things are built with a shelf-life in mind and that's ok

3. Craftsmanship
- When solving a problem, do so sustainably
- Always strive to improve our process and learn from missteps

4. Lift your team
- Help others grow
- Strive to make people feel better, not worse
- Strive to create an inclusive culture supporting diverse opinions
- Be solution oriented
engineering  engineering_management  team  team_management  management  culture  values  is:tweet 
september 2018
Ryan Singer on Twitter re: estimation versus budgeting
Estimation requires knowing what you’re doing. That means you can estimate downhill but not uphill. You can, however, *budget* anywhere. That is, set a maximum amount of time you’re willing to spend. Budgeting != estimating.
quote  estimation  projectmanagement  software_engineering  development  is:tweet  team 
september 2018
Repeat yourself, do more than one thing, and rewrite everything
The problem with always using an abstraction is that you’re preemptively guessing which parts of the codebase need to change together. “Don’t Repeat Yourself” will lead to a rigid, tightly coupled mess of code. Repeating yourself is the best way to discover which abstractions, if any, you actually need.

As Sandi Metz put it, “duplication is far cheaper than the wrong abstraction”.
programming  abstraction  bestpractices  software_engineering  software_architecture  development  inspiration  advice 
august 2018
Action Salzman 📎 @chrissalzman
august 2018
The Cost Of JavaScript In 2018 – Addy Osmani – Medium
*If client-side JavaScript isn’t benefiting the user-experience, ask yourself if it’s really necessary.* Maybe server-side-rendered HTML would actually be faster. Consider limiting the use of client-side frameworks to pages that absolutely require them. Server-rendering and client-rendering are a disaster if done poorly.
javascript  performace  web  webdevelopment  bestpractices 
august 2018
Create beautiful screenshots with device mockups
design  tool  screenshot  marketing 
august 2018
Elided Branches: Delegation: When being helpful is actually hurting
So the next time you find yourself tempted to volunteer to take over responsibility for something from someone who reports to you, pause. Instead of taking it over, ask them what they think the next steps should be. Give your feedback, and let them bring the follow-ups to you in the next appropriate touch base. You owe it to them to stop taking over their work in the name of helpfulness.
delegation  management  time_management  productivity  team 
august 2018
Francisco Tolmasky on generic UX flows
With mobile, UX started investing heavily into highly specialized workflows, admittedly making them much easier than in the old desktop world, but dropped the ball on the “generic” interactions of computing. So if the task wasn’t predicted, it became nearly impossible to do.

is:tweet  design  ux  mobile  truth 
august 2018
gaia-pipeline/gaia: Build powerful pipelines in any programming language.
gaia is an open source automation platform which makes it easy and fun to build powerful pipelines in any programming language. Based on HashiCorp's go-plugin and gRPC, gaia is efficient, fast, lightweight and developer friendly. Gaia is currently alpha! Do not use it for mission critical jobs yet!
go  golang  build  ci  devops  data  data_engineering  engineering  development  is:repo 
july 2018
Tweet on Slack being bad for technical decisions
There's nothing quite as nefarious as a technical decision made via Slack: stakeholders miss it if they're not around, points are poorly stated as they're strung across 50 half-baked thoughts, context exists across pages of jumbled noise, *and* it's time consuming.

I miss email.
team  management  communication  email  chat  slack  quote  is:tweet 
july 2018
Donut Manifesto | The importance of donuts | Lara Hogan

Years ago, I found that whenever something awesome happened in my career – maybe I got published, or promoted, or launched a project – I wouldn’t take the time to celebrate the achievement. I’m an achiever by nature, the kind who feels like every day starts at zero. Not deliberately marking these moments left me feeling like I wasn’t actually accomplishing anything. “Oh cool, that A List Apart article went up,” I would think, then move on with my day.

Once I realized that this was happening, I decided to be deliberate about marking achievements by eating one donut. Well, sometimes more than one, if it’s a really big deal. The act of donut-eating has actually helped me feel like I’m accomplishing my career goals. As I started to share this idea with more people, I found that it resonated with others, especially young career-driven women who are routinely achieving goals and furthering their career but don't take the time to note their own success.

I decided to start celebrating in a public way so that more people may be inspired to find their own ways of marking their career achievements.
productivity  motivation  fun  humor  team  management 
june 2018
Josh Pigford on running a software business – Twitter Thread
This whole thread on what Josh learned running a software business is solid 👌

Two good callouts:
20/ The Next Feature Fallacy is real and will cloud your thinking dramatically. Like it or not, that next feature that you’re so excited about will categorically, as an individual unit, do nothing for your business. But man if we don’t like to think it will.
“Busy” does not equal “productive”. You shouldn’t be doing 1,000 different things. Business isn’t that complicated. Very few things are urgent. Very few things actually even need to get done. As a founder, pick just 1 or 2 “must do” things each day
is:tweet  business  inspiration 
june 2018
Mikov's Blog: You Don't Like Google's Go Because You Are Small
Trust me, you don’t need the ternary operator “?:“. It is too complex for you, with your small mind.
You might end up needing something like that in a very obscure corner case which is referred by computer scientists as “calling methods of objects”.

Ultimately a good articulation of what I think of Go:
I don’t “hate” Go, I think there is lot there to like, and that is precisely why its big failings bother me even more.

I view Go as a huge wasted opportunity.
go  golang  programming  google  via:dadrian 
april 2018
Static CMS for Hugo & Jekyll |
Sync your Jekyll or Hugo site. Your editors will love it and won’t realize they’re making commits.

Seemingly a web UI CMS to update s static site with commits still as the backend changelog.
staticsite  jekyll  hugo  cms  wordpress  website 
april 2018
Tabler - Admin panel made simple
Premium and Open Source dashboard template with responsive and high quality UI. For Free!

This can act as a nice reference implementation of skinning [Bootstrap][1]

css  templates  design  web  webdesign  via:andyfowler  twitter_bootstrap  sass 
april 2018
Jason Fried @jasonfried

Twitter is beginning to feel like secondhand smoke. The amount of anger and anxiety you walk into just browsing your timeline is like walking into a cloud of cigarette smoke from the smoker in front of you.
twitter  deep_work 
april 2018
Augmenting Artworks: AR at Artsy - Artsy Engineering
Remember, React Native is native, so you can write chunks of your app without ever touching RN's toolchain:
React Native is really great for nearly every screen we deal with typically. We tend to basically build pretty screens of JSON. This experience is far from that. It requires constantly changing states between two very separate but linked worlds. One of the biggest advantages to doing it in React Native would have been using it for cross-platform work, but that’s speculative as only ARKit supports vertical plane detection today. We’d have had to either use a dependency, or build our own simpler bridge from ARKit to JS and maintain that. It just felt like a lot of work for a one-off section of the app.
react  ReactNative  reactjs  iOS  uikit  arkit  native  development 
april 2018
Ryan Singer on Twitter: ""Design decisions can have enormous, cascading effects" — Yes. That's why we "integrate uphill" at Basecamp. We learn together by building rough concepts with clickable UI and real code on staging servers with real data. There's
"Design decisions can have enormous, cascading effects" — Yes. That's why we "integrate uphill" at Basecamp. We learn together by building rough concepts with clickable UI and real code on staging servers with real data. There's no risky hand-off step.
is:tweet  design  development  prototyping  iteration  risk 
march 2018
N+1 is a Rails feature -
N+1 is a feature, which is usually seen as a bug, right?

If you have N+1 query it means you're executing one SQL query per element so if you have 50 emails in an inbox, that'd be 50 SQL calls, right? That sounds like a bug. Well in a Russian doll caching setup, it's not a bug, it's a feature. The beauty of those individual calls are that they're individually cached, on their own timeline, and that they're super simple.

Because the whole way you get around doing N+1 queries is you do joins; you do more complicated queries that take longer to compute, and tax the database harder. If you can simplify those queries so that they're super simple, but there's just more of them, well, you win if and only if you have a caching strategy to support that.
activerecord  rails  sql  database 
march 2018
Distributed “versus” HQ Org Structures – Learning By Shipping
Industry experiencing helping support [Conway's Law](

Early on when it comes to balancing work and assigning who does what, the skills of people almost always defines who does what. […] the next derivative of this is that the overall product architecture is thus defined by the location of people. This is literally shipping the org chart, but without really deliberately deciding that.

Very tough to over-state how massive a future constraint this will be. When we say “don’t ship the org chart” baking in these architectural boundaries literally cements the path the team will take to evolve the product. Very risky while establishing P-M-Fit.

As an example, if you allocate work to people based on front-end/back-end simply because of skills and those people are remote, as you scale these teams (in terms of number of people) you are “cementing” this definition of an API between subsystems (you can take this to any level of granularity — not just UI/back end, but where data resides, how subsystems communicate, etc.). These APIs come to define not just the elegance of how a product works BUT importantly the seams to overcome and constraints in what can be done over time.

Many say things like “separate UX from back end” for ex., because those are two types of Eng. BUT where to put code is often a competitive/feature advantage not something done simply for consistency of strategy/architectural purity. Innovation breaks old notions of abstraction.


APIs seem like such an elegant and desirable approach for how remote teams work. In practice, APIs are great for external users of products to extend them because they are “contracts”. But why enforce and live with a contract internally? A role of a company can be to operate without such hard boundaries within the company. There’s a massive execution challenge that comes from building a single product composed of APIs across components. It slows innovation and builds “dependencies” across what would otherwise be “teammates”. It becomes very tough to scale and manage over time.
conways_law  team  management  product_management  engineering  engineering_management  remote-work  microservices  api 
march 2018
Google Takeout – Download your data
Create an archive with your data from Google products.
backup  google  gmail  privacy  tools 
march 2018
Create and share beautiful images of your source code.
Start typing or drop a file into the text area to get started.

Great for generating nice looking code examples in Keynote slides. The only problem with an image is the lack of text and hence copy-and-paste capabilities of your slides.
tool  code  presentation 
march 2018
Three flavours of iteration

- Scientific iteration is about shipping to prioritise learning. This is where the Eric Ries Lean Startup fans hang out.

- Greedy iteration is about shipping incrementally to get the value of each increment sooner. This is where the Dan Reinertsen Cost of delay kids are.

- Defensive iteration is building incrementally parts of a whole, not for the value of any increment specifically, but so you’ve defended against having an incoherent whole when an arbitrary product cycle closes. This is the domain of “potentially shippable increment” scrum types.

In short: iteration can mean a few different things, each thing has pros and cons but misalignment is all cons, so double check you’re all aligned and be kind to each other.
via:andyfowler  team  iteration  development  product_management  agile 
february 2018
« earlier      
per page:    204080120160

Copy this bookmark:

to read