The Misreading of Mitski | The New Yorker
Jia Tolentino writes about the persona that the artist Mitski has constructed across her albums, including “Be the Cowboy,” “Puberty 2,” and “Bury Me at Makeout Creek.”
17 hours ago
SnapshotTesting 1.0: Delightful Swift snapshot testing
The iOS community has been a large proponent of snapshot testing, mostly thanks to the wonderful iOSSnapshotTestCase library (formerly known as FBSnapshotTestCase). It introduced a new kind of test coverage for iOS applications by allowing us to assert against an image screenshot of a UI component. This is a whole new level of testing that can catch regressions in the pixel data of our UI so that you can make sure that future changes and refactors do not introduce visual regressions into your views.

However, iOSSnapshotTestCase has not evolved much over the years, and its still largely written in Objective-C, which means the API isn’t as generic and composable as it could be in Swift. Also, it only allows snapshotting CALayers and UIViews into a PNG format, but there are many more types we might want to snapshot and many more formats we want to snapshot into.

That’s why today we are excited to officially announce SnapshotTesting 1.0: a modern, composable snapshot testing library built entirely in Swift!
lang:swift  ios  uikit  ui  testing  snapshots 
6 days ago
Move over Starbucks - Cake Pops are as easy to make as they are to eat!
First, bake a cake according to the package instructions. You can choose any flavor you desire. I used chocolate and vanilla.

Let cool completely (1-1 1/2 hours).

Crumble cake into very small pieces in a bowl.

Mix with frosting (choose a flavor that complements cake) until it's sticky consistency that forms easily into balls. Note: Too much or not enough frosting will not form balls well, so start off with little and add more gradually.

Roll cake into balls.

Put on a baking sheet covered with wax paper and chill in fridge for 1-1/2 hrs. or until firm.

Melt chocolate pieces in microwave according to package instructions.

Dip lollipop stick in the melted chocolate and insert into cake ball.

Return the cake pop to the fridge until the chocolate hardens (couple minutes).

Dip the cake pop into melted chocolate and allow it to drip down the sides. You can sprinkle with various toppings to dress them up.

Insert the cake pop into a styrofoam piece to dry (you can get these at any craft store).
recipe  dessert  cake 
6 days ago
Advice for a new executive | Lara Hogan
Find/create a peer support group
Partner absurdly closely with product and make sure you understand priorities and the head of product understands tradeoffs
Focus on delivery of the roadmap and everything else will follow
Ask your executive peers regularly what you can do to make their jobs easier – particularly the CEO
Take a stand when you need to
Always have a story
Read widely – offline! – about management and leadership
Realize the impact your mood and demeanor has on people
Develop the right relationship with members of your company’s board
leadership  management  career  advice 
12 days ago
How Boomer Homeowners Blocked Affordable Housing - CityLab
In Generation Priced Out, Randy Shaw examines how Boomers have blocked affordable housing in urban neighborhoods, leaving Millennial homebuyers in the lurch.
urbanism  density  housing  millennials  affordability  environmentalism  zoning 
23 days ago
Cul-de-sac Hell and the Radius of Demand — Human Transit
In short, this structure is a labyrinth for cars, as cul-de-sacs are meant to be, but for pedestrians and cyclists it’s more like a grid.  Every city should be looking for places where they can retrofit this sort of pedestrian connection.
urbanplanning  transportation 
27 days ago
scrum - What is the purpose of the stand-up and its duration in agile methodologies? - Software Engineering Stack Exchange
The Daily Scrum is a 15-minute time-boxed event for the Development Team to synchronize activities and create a plan for the next 24 hours. This is done by inspecting the work since the last Daily Scrum and forecasting the work that could be done before the next one. The Daily Scrum is held at the same time and place each day to reduce complexity. During the meeting, the Development Team members explain:

What did I do yesterday that helped the Development Team meet the Sprint Goal?

What will I do today to help the Development Team meet the Sprint Goal?

Do I see any impediment that prevents me or the Development Team from meeting the Sprint Goal?

The Development Team uses the Daily Scrum to inspect progress toward the Sprint Goal and to inspect how progress is trending toward completing the work in the Sprint Backlog. The Daily Scrum optimizes the probability that the Development Team will meet the Sprint Goal. Every day, the Development Team should understand how it intends to work together as a self-organizing team to accomplish the Sprint Goal and create the anticipated Increment by the end of the Sprint. The Development Team or team members often meet immediately after the Daily Scrum for detailed discussions, or to adapt, or replan, the rest of the Sprint’s work.

The Scrum Master ensures that the Development Team has the meeting, but the Development Team is responsible for conducting the Daily Scrum. The Scrum Master teaches the Development Team to keep the Daily Scrum within the 15-minute time-box.

The Scrum Master enforces the rule that only Development Team members participate in the Daily Scrum.

Daily Scrums improve communications, eliminate other meetings, identify impediments to development for removal, highlight and promote quick decision-making, and improve the Development Team’s level of knowledge. This is a key inspect and adapt meeting.
scrum  agile  bestpractices 
28 days ago
JSON5 | JSON for Humans
The JSON5 Data Interchange Format (JSON5) is a superset of JSON that aims to alleviate some of the limitations of JSON by expanding its syntax to include some productions from ECMAScript 5.1.
json  es5 
5 weeks ago
sharkdp/fd: A simple, fast and user-friendly alternative to 'find'
fd is a simple, fast and user-friendly alternative to find.

While it does not seek to mirror all of find's powerful functionality, it provides sensible (opinionated) defaults for 80% of the use cases.
cli  find  tool 
5 weeks ago
[renaud _lienhart]; on Twitter: <thread> Developing an iOS app in 2018
Disregarding the limited utility of the app for most of you, I’d just like to quickly talk about how developing an iOS app from scratch in 2018 feels like.

First of all, the basic architecture of the app: we use MVVM-Rx layered in modules, and the only couple “real” dependencies we have is RxSwift and RxDataSources. The vast majority of the code is purely functional and reactive. It is a pleasure to read as well as to write.

Secondly, Swift. From Value Types to CaseIterable, passing by Decodable, Generics, Auto-Synthesised E&H conformances, Keypaths and the power of its Enums, Swift has become an essential pillar of the code we write. I love Objective-C, but I would never want to go back.

The Standard Lib is a pleasure to interact with and feels *almost* complete. I just wish its documentation was better, e.g. clearly enunciating the constraints on a Generic Type for a method to become available.

Xcode and LLDB still have some way to go to become reliable. Swiftc’s error messages are still very poor and require a lot of implicit knowledge of the language in order to decipher what the compiler is actually complaining about. The new build system is amazing.

Finally, UIKit and other related frameworks. It is _shocking_ how bad & buggy iOS <11 was. Since then however, the fundamentals got robust and behave exactly as expected. You can (mostly) trust UIKit now, and be confident that any bug is in your code rather than Apple’s.

I wish there were better Swift wrappers around the ObjC frameworks’ interface. Apart from sometimes adding default arguments, there is so much potential that could be unleashed by having access to Swift-only frameworks.

I am very excited by what may be unveiled in 2019.

Overall this was, and continues to be, an amazing codebase to work on. iOS development, thanks to technologies such as Swift and FRP, has come a long way from what it was just a few years ago. You don’t need a boatload of cocoapods anymore. You don’t need a team of 50 engineers to maintain a bunch of dynamic code and the thousands of unit tests it entails.

All you need is a fresh, modern, trustworthy approach to writing apps. And 2018’s iOS provides that.
ios  development  ios11  ios12  uikit  swiftlang  xcode  rx  frp  mvvm  reactiveprogramming  is:tweet 
6 weeks ago
Roy Fielding’s REST dissertation – Ole Begemann
I recently read Roy Fielding’s 2000 PhD thesis, Architectural Styles and the Design of Network-based Software Architectures, in which he introduced and described REST. Here’s what I learned.
rest  http  history  HATEOAS  api 
6 weeks ago
twitchtv/twirp: A simple RPC framework with protobuf service definitions
Twirp is a framework for service-to-service communication emphasizing simplicity and minimalism. It generates routing and serialization from API definition files and lets you focus on your application's logic instead of thinking about folderol like HTTP methods and paths and JSON.
rpc  grpc  rest  json  lang:go  is:repo  protobuf 
6 weeks ago
Michael Tsai - Blog - Custom Icons for Quick Actions
Matthias Gansrigler:

The trick is to have the file end in ‘Template’, like ‘MyWorkflowIconTemplate.tiff’. But that’s not all there is to it. When you add a custom icon through Automator, it automatically gets renamed into ‘workflowCustomImage.png’. So no matter what you name your file, it won’t matter.

To fix this, add a custom icon to your Quick Action in Automator, save, switch to Finder and navigate to /Users/yourname/Library/Services/, where your newly saved Quick Action will end up. There, right-click your Quick Action, select ‘Show Package Contents’, and navigate into Resources, where your icon file will be. Rename it to ‘workflowCustomImageTemplate.png’. Now, navigate into Contents and open Info.plist. Look for <key>NSIconName</key> and change ‘workflowCustomImage’ to ‘workflowCustomImageTemplate’. Save.

You can use Quick Actions with both DropDMG and EagleFiler. The main catch, from my perspective, is that Finder accepts click-through for them. So if you have a habit of bringing Finder windows to the front by clicking near the bottom-right, be aware that you may accidentally invoke a Quick Action.

Gansrigler also has a tip for making the right kind of TIFF file for the Touch Bar. However, you don’t have to write code to do this. You can make a multi-representation TIFF using tiffutil.
macos  osx  macos_mojave  finder  services  quick_actions 
7 weeks ago
GoogleContainerTools/jib: Build container images for your Java applications.
Jib builds Docker and OCI images for your Java applications and is available as plugins for Maven and Gradle.


• Fast - Deploy your changes fast. Jib separates your application into multiple layers, splitting dependencies from classes. Now you don’t have to wait for Docker to rebuild your entire Java application - just deploy the layers that changed.

• Reproducible - Rebuilding your container image with the same contents always generates the same image. Never trigger an unnecessary update again.

• Daemonless - Reduce your CLI dependencies. Build your Docker image from within Maven or Gradle and push to any registry of your choice. No more writing Dockerfiles and calling docker build/push.
java  jvm  docker  gradle  maven  tool 
7 weeks ago
More shell, less egg - All this
What people remember about his review is that McIlroy wrote a six-command shell pipeline that was a complete (and bug-free) replacement for Knuth’s 10+ pages of Pascal.
7 weeks ago
GD2md-html - Google Docs add-on
Drive add-on that converts a Google Doc to simple, readable Markdown or HTML.

gd2md-html converts Google Docs to simple, readable Markdown or HTML.

This add-on allows you to create documents using the excellent editing and collaborative features of Google Docs, but publish as Markdown or HTML that you can store as text files using a version-control system.

See https://github.com/evbacher/gd2md-html/wiki for docs.
google  google_docs  tool  markdown  html 
7 weeks ago
Don't Be A Hero — Alex Payne
Here’s the thing: the hero is the most damaging person on a team, particularly on a team that’s supposed to be writing high-availability or otherwise mission-critical software.
startups  culture  rockstars  management  health 
7 weeks ago
"Mapping Imaginary Cities" by Mouse Reeve - Strange Loop 2018 - YouTube
While the map is not the territory (to quote the semantician Alfred Korzybski), the map is still usually intended to correspond to one. But what about maps of nowhere at all? What can they represent and how can they be made?

Maps are a familiar part of daily life, with a deeply familiar and complex symbolic language, and a long history. They are also hugely varied in style and aesthetic, and often are works of art unto themselves. All this makes mapping a powerful creative tool for conveying ideas about a space, how it is used, and who inhabits it. But it also presents a mapmaker with what can feel like an overwhelming array of design choices and technical hurdles to overcome in order to create a generative map.

This talk will explore maps as a way to communicate about people and place in the context of fictional cities, and dive into algorithms and techniques for procedurally generating maps by building up topography, landscape, populations, and street plans.

Speaker: Mouse Reeve
cartography  maps  art 
7 weeks ago
Jared Sinclair | Blog | TIL: Boy, Have I Been Misusing SCNetworkReachability
SCNetworkReachability should only be used to influence what you do about a network request that has already failed, not an initial request that has yet to be attempted. Use a negative status to determine whether or not you attempt an automatic retry, or to tweak the user-facing language of an alert. Use a positive status to consider retrying an earlier failed request. Never prevent a user-initiated request from being attempted just because SCNetworkReachability thinks there’s not a reachable network.
SCNetworkReachability  reachability  networking  iso  bestpractices 
8 weeks ago
The Illustrated TLS Connection: Every Byte Explained
The Illustrated TLS Connection
Every byte of a TLS connection explained and reproduced.
tls  networking  https  ssl 
9 weeks ago
Repeat yourself, do more than one thing, and do more than one thing — programming is terrible
If you ask a programmer for advice—a terrible idea—they might tell you something like the following: Don’t repeat yourself. Programs should do one thing and one thing well. Never rewrite your code from scratch, ever!.

Following “Don’t Repeat Yourself” might lead you to a function with four boolean flags, and a matrix of behaviours to carefully navigate when changing the code. Splitting things up into simple units can lead to awkward composition and struggling to coordinate cross cutting changes. Avoiding rewrites means they’re often left so late that they have no chance of succeeding.

The advice isn’t inherently bad—although there is good intent, following it to the letter can create more problems than it promises to solve.

Sometimes the best way to follow an adage is to do the exact opposite: embrace feature switches and constantly rewrite your code, pull things together to make coordination between them easier to manage, and repeat yourself to avoid implementing everything in one function..

Repeat yourself, but don’t repeat other people’s hard work. Repeat yourself: duplicate to find the right abstraction first, then deduplicate to implement it.

With “Don’t Repeat Yourself”, some insist that it isn’t about avoiding duplication of code, but about avoiding duplication of functionality or duplication of responsibility. This is more popularly known as the “Single Responsibility Principle”, and it’s just as easily mishandled.

Gather responsibilities to simplify interactions between them

The only real difference between pushing something together and pulling something apart is that some changes become easier to perform than others.

The choice between a monolith and microservices is another example of this—the choice between developing and deploying a single service, or composing things out of smaller, independently developed services.

The big difference between them is that cross-cutting change is easier in one, and local changes are easier in the other. Which one works best for a team often depends more on environmental factors than on the specific changes being made.

Although a monolith can be painful when new features need to be added and microservices can be painful when co-ordination is required, a monolith can run smoothly with feature flags and short lived branches and microservices work well when deployment is easy and heavily automated.

Modularity is more than reducing things to their smallest parts.

A layer of small components with no shared features creates a need for a layer above where these features overlap, and if absent, the user will create one, with bash aliases, scripts, or even spreadsheets to copy-paste from.

Even adding this layer might not help you: git already has a notion of user-facing and automation-facing commands, and the UI is still a mess. It’s always easier to add a new flag to an existing command than to it is to duplicate it and maintain it in parallel.

Similarly, functions gain boolean flags and classes gain new methods as the needs of the codebase change. In trying to avoid duplication and keep code together, we end up entangling things.

Although components can be created with a single responsibility, over time their responsibilities will change and interact in new and unexpected ways. What a module is currently responsible for within a system does not necessarily correlate to how it will grow.

Modularity is about limiting the options for growth

A given module often gets changed because it is the easiest module to change, rather than the best place for the change to be made. In the end, what defines a module is what pieces of the system it will never responsible for, rather what it is currently responsible for.

This means recognizing which bits are slightly more entangled than others, knowing which pieces need to talk to each other, which need to share resources, what shares responsibilities, and most importantly, what external constraints are in place and which way they are moving.

In the end, it’s about optimizing for those changes—and this is rarely achieved by aiming for reusable code, as sometimes handling changes means rewriting everything.

Rewrite Everything

The reason rewrites are so risky in practice is that replacing one working system with another is rarely an overnight change. We rarely understand what the previous system did—many of its properties are accidental in nature. Documentation is scarce, tests are ornamental, and interfaces are organic in nature, stubbornly locking behaviors in place.

If migrating to the replacement depends on switching over everything at once, make sure you’ve booked a holiday during the transition, well in advance.

Successful rewrites plan for migration to and from the old system, plan to ease in the existing load, and plan to handle things being in one or both places at once. Both systems are continuously maintained until one of them can be decommissioned. A slow, careful migration is the only option that reliably works on larger systems.

The reason we say “Never Rewrite Code” is that we leave rewrites too late, demand too much, and expect them to work immediately. It’s more important to never rewrite in a hurry than to never rewrite at all.

null is true, everything is permitted

The problem with following advice to the letter is that it rarely works in practice. The problem with following it at all costs is that eventually we cannot afford to do so.

It isn’t “Don’t Repeat Yourself”, but “Some redundancy is healthy, some isn’t”, and using abstractions when you’re sure you want to couple things together.

It isn’t “Each thing has a unique component”, or other variants of the single responsibility principle, but “Decoupling parts into smaller pieces is often worth it if the interfaces are simple between them, and try to keep the fast changing and tricky to implement bits away from each other”.

It’s never “Don’t Rewrite!”, but “Don’t abandon what works”. Build a plan for migration, maintain in parallel, then decommission, eventually. In high-growth situations you can probably put off decommissioning, and possibly even migrations.
dry  srp  programming  bestpractices  refactoring  maintenance  modularity  onethingwell 
9 weeks ago
The Math behind Project Scheduling, Bug Tracking, and Triage | USENIX
Many projects have poorly defined (and often overridden) priorities, hopelessly optimistic schedules, and overflowing bug trackers that are occasionally purged out of frustration in a mysterious process called "bug bankruptcy." But a few projects seem to get everything right. What's the difference? Avery collected the best advice from the best-running teams at Google, then tried to break down why that advice works—using math, psychology, an ad-hoc engineer simulator (SimSWE), and pages torn out of Agile Project Management textbooks.

We'll answer questions like:

• Why are my estimates always too optimistic, no matter how pessimistic I make them?
• How many engineers have to come to the project planning meetings?
• Why do people work on tasks that aren't on the schedule?
• What do I do when new bugs are filed faster than I can fix them?
• Should I make one release with two features or two releases with one new feature each?
• If my bug tracker is already a hopeless mess, how can I clean it up without going crazy or declaring bankruptcy?
project_management  software  estimation  agile  kanban  bug_tracking  bestpractices  is:video 
9 weeks ago
A How-To Manual for Fixing Badly Planned Cities - CityLab
If nothing is close to anything different, and the only connection is a single fat roadway, then the population is automatically conscripted into driving.
zoning  urbanplanning  urbanism  cities  cars  design  cycling 
9 weeks ago
« earlier      
373proj a2council accessibility affordability algorithms america android animation annarbor api apple applewatch appstore art async autolayout aviation bash bestpractices business c c++ charting ci clang cli clips clojure cocoa cocoa_touch cocoapods coffee color complexity concurrency coreanimation coredata cryptography cs css culture cycling d3 data debugging dependency-injection design designpatterns detroit development diversity diy dmx512 documentation economics elecdiy electronics embedded encryption engineering english enum error_handling extensions facebook filetype:pdf finance flying foia font friends functionalprogramming game gcd generics gif git github golang graphics health history housing html html5 http humor icons inspiration internet interop ios ios10 ios7 ios8 ios9 is:gist is:repo is:tweet is:video java javascript journalism jquery json kvo lang:swift layout life lighting linux lldb management markdown matlab media:document memorymanagement michigan mocking music mvvm networking newspapers nginx notifications nsa nsurlsession nyc nytimes nytnow objective-c oop option_type osx parser performance photog photography politics privacy productivity programming protocol_extensions protocols python quote radio reactivecocoa reactiveprogramming reactjs reactnative refactoring reference resources rest ruby rust_lang rx safety search security simplicity society software software_architecture solid ssl startups strings swiftlang sysadmin taxes tdd testing tls tool tools transit travel tutorial twitter types ui uicollectionview uiimage uikit uitableview uiviewcontroller umich unicode unix urban_development urbanplanning ux via:andrewsardone via:androidweekly via:cdzombak via:iosdevweekly via:mattb visualization watchkit water weather web_dev windows wordpress work xcode xctest zoning

Copy this bookmark: