recentpopularlog in

robertogreco : jessekriss   4

GitHub - jkriss/zinepdf
"This is a short Python 2 script that will take a 7-8 page pdf, legal size, and turn it into a single sheet foldable zine."
jessekriss  python  zines  papernet  typesetting  printing  print 
4 weeks ago by robertogreco
GitHub - jkriss/altcloud: A web server with extra powers. Run your own stuff.
"Altcloud is a web server with some niceties build in so that you can create real applications without any backend code or external services.

The idea is to set up an altcloud server on something like a Digital Ocean instance or a C.H.I.P. and run multiple sites off of that single server.

Altcloud is powered by simple configuration files and uses the local filesystem for storage. It doesn't scale, and that's just fine.

This implementation of the altcloud server is written in node.js, but the specification is platform and language agnostic.

DISCLAIMER: this is beta software. Please don't trust it just yet."
jessekriss  altcloud  cloud  diy  web  webdev  servers  software  applications  webdesign 
february 2017 by robertogreco
Human scale technology — Medium
[video now here: https://vimeo.com/180044030

"Human-Scale – Beyond user-centered design, we need to create systems that are explicitly and deliberately built to be humane. What does this mean, and is it in conflict with existing corporate structures?"]

"To me, the idea of human scale is critical. It’s easy to fall into the trap of thinking that every idea must scale. That thinking is distracting, closes us off from great opportunities, and invites unnecessary complexity.

Turn down the amplifier a little bit. Stay small. Allow for human correction and adjustment. Build for your community, not the whole world.

At this scale, everybody counts. Plus, we get a few other benefits.

Small is simpler. This is good from a pure engineering and design perspective. We strive for simplicity in the structures we build.

Even better, though, small things are more accessible.

You don’t need a full team of fancy Google engineers to build something small. You can be new to programming, or a hobbyist. You don’t have to be born in the right place at the right time to the right parents.

Simpler systems are easier to create, deploy, and maintain.

More people can be the creators and tinkerers, and not just the users.

If you make it small, it’s also cheap to run. You can build a service that supports thousands of people on a $5/month server, or a Raspberry Pi.

So cheap, most likely, that you don’t have to charge anybody for it. With the right architecture, you can run community-size services for less than $10/month, total.

And if this works, we can tackle the issue of incentives.

Not to get all Ben Franklin on you, but if you don’t spend money, you don’t have to make money.

If complexity drops, and cost drops, the community can now build its own systems. Incentives align.

So, it really comes down to this:

Do it yourself. Strip it down. Keep control. Make it for your community. Don’t do it for the money.

And this is where I start to understand what my friend Rebecca Gates means when she says that technologists and designers have a lot to learn from punk and indie rock.

Leave the expensive, large scale, commercial arena rock to Facebook, Google, and Twitter.

We can be The Ramones.

And Bad Brains.

We can press our own records, and run our own labels.

We can make our own spaces based on our own values.

And remember that computing used to be pretty punk rock.

This is the first public computerized bulletin board system, which was set up in a record store in Berkeley in 1973.

In 1974, the year the Ramones formed, Ted Nelson wrote the first book about the personal computer.

It contained perhaps my favorite opening line of any piece of literature: “Any nitwit can understand computers, and many do.”

It was basically a giant zine.

We can reclaim autonomy and agency with the incredible tools we have at hand–we just need to approach it differently."
scale  small  accessibility  simplicity  slow  sfsh  lcproject  openstudioproject  punk  design  web  online  community  theramones  badbrains  scrappiness  diy  values  eyeo  eyeo2016  jessekriss  intimate  safe  groupsize  humans  humanism  humanscale  paulgoodman  efschumacher  ursulafranklin  incentives 
june 2016 by robertogreco
Anti-capitalist human scale software (and why it matters) — Medium
"Twitter launches features no one wants. Parse shuts down. Websites track us to an astonishing degree. Corporations close down open systems. They turn over our data to the government.

Software and services that are supposed to make life better are becoming unreliable and untrustworthy. It is increasingly clear that our interests, as software-using humans, are diverging from the interests of software companies.

I am coming to the conclusion that we simply can’t rely on corporations to produce and maintain great, reliable, human-centered software. The systems and incentives are in direct conflict.

In my mind, one of the core problems is a lack of agency. If Twitter or Facebook push out a feature that is destructive to the way we use their services, or they refuse to create tools that are plainly necessary, we can do little but complain. As individual, non-paying users, we have virtually no leverage.

There’s also a lack of agency on the building side of the things. With open systems, we have the opportunity to create and run our own variants of systems that better suit our purposes. When APIs and app stores are tightly controlled, even our ability to usefully augment the system is curtailed.

So, short of overthrowing capitalism, what can we do?

Amidst the pessimism, I do think we still have a chance to build a different path. The only way to meaningfully diverge from the existing trends is to consciously embrace new values and different constraints. To that end, here are a new set of principles:

The community should have final say.

We need to reintroduce agency. Each particular community (not necessarily the entire user base — more on this later) should be able to decide if they want to accept the latest update of a given service or not. If a community cannot shape systems to reflect their values, those systems are flawed.

Scale is a trap.

So much of the complexity of web engineering comes from questions of scale. But why do we need scale? If we are trying to build humane software, there are significant benefits to keeping things smaller and simpler. If you want to run something for hundreds of people–or even thousands–that is entirely sustainable on a single cheap shared server.

Hubs, not monoliths.

A critical piece of this is creating systems that are somewhere in between the giant, corporate systems and the completely distributed everyone-run-their-own-peer, everyone-needs-to-be-a-hacker approach. I am inspired by projects like Artisanal Integers, which I initially thought was a throwaway joke, but is actually a fascinating model to work ourselves out of these centralized systems.

These hubs can be operated by an individual or a small group on behalf of a community. As long as there is sufficient agreement between the hub operators about rules of interoperability, each hub can maintain a level of autonomy. The community of people using it can control its direction. And, ultimately, if one community chooses to break from the larger system, that is an option that is available to them.

Allow the community to create."
scale  software  socialmedia  community  hubs  networks  distributed  jessekriss  complexity  simplicity  web  online  humaneness  artisinalintegers  decentralization  interoperability  capitalism  twitter  apis 
february 2016 by robertogreco

Copy this bookmark:





to read