csytan

  "What does it take to... join the same market space?"

Speaking on the SAAS space. IMO the bar for entry is getting higher every year. It's getting easier and easier to build apps, and the number of developers keeps growing.

What does it take to join the same market space? Here's some strategies:

1. Find a niche that is being ignored and really needs your specific product. This is getting harder to do.

2. Raise money. One way to build a good product is to throw good developers at it.

3. Give yourself a longer runway. Think years instead of months.

4. Buy an existing business, and run it yourself.

   "Are there cases where there is only room for one player and no matter what you do, you will not be able to steal any sizeable amount of market share from them?"

Definitely. If you go very niche, you'll find areas where there is a strong competitor dominating small a space. It might not be worth entering the space because the market is so small.

My wife and I are bootstrapping a business, and we're nearly at 100 customers (92 right now). I would not say it's an easy road. We've been working on it full time for 1.5 years so far.

A couple things I've realized while doing this:

1. Business is a competition. Much like in sports, skills are only built up through practice. For an entrepreneur this means actually selling something. You will start at level 0. There is no substitution for actually doing the work.

2. The bigger you grow, the easier it gets. A year ago we were running around like headless chickens not knowing what to focus on. Now that we've got a core group of customers, and it's much easier to decide where to go. We can start to plan a month or two months out now. Opportunities such as partnerships also present themselves as your business grows larger.

You should check out notion.so

I've been looking into this as well. Here's some notes: https://www.notion.so/csytan/iPad-as-a-Development-Device-99...

Could you clarify? I'm guessing you mean..

Square: Small/individual merchants, Etsy style physical shops, trade shows, etc.

Stripe: large retailers, grocery stores, stores with many locations etc.

It's interesting to see:

- Square become Stripe, while Stripe becomes Square

- Stripe owning the whole user experience in purchasing

- If they own the physical end points, will they eventually cut out credit card companies? You can already see that they are pushing for collecting emails with checkout.js. The first step is to have direct contact with the end user.

- If they cut out credit card companies, what's to stop them from moving into personal payments (e.g. Square Cash, Venmo) and then banking?

Sellers are customers too, but I think that in this context it means the people who make purchases on Amazon.

Python3 + tornado + peewee + sqlite3 + vuejs hosted on Digital Ocean.

I've been using this combo in production for https://www.cozycal.com for a year with no problems.

Likes: - More control than hosted environments - Dirt cheap

Dislikes: - More responsibility than hosted environments

Co-operatives have been around for a long time outside of the software world. The low level problems are being worked on right now with DAOs, but it will take a while longer.

If you take the D out of DAO, then the high level problems: fairness and trust, can already be worked upon.

Are there any organizations that have tied software decision making to the existing legal system?

Music also has much more replay-ability than movies.

Here's a great community for just that: https://www.indiehackers.com/

Coincidentally, Indie Hackers was acquired by Stripe via patio11.

When I was living in NYC, cycling to work in the summer was the best part of my day. It took me ~30 mins to get from the Upper West Side to the office in Alphabet city. Commuting by subway would take ~50 mins.

The two I'd recommend are: 1. https://giphy.com/apps/giphycapture 2. https://getkap.co/

This is not surprising to me. I've worked in this space, and I think consumer hardware startups are just incredibly hard. I just finished my stint at one (https://www.electricobjects.com/) last year after we failed to raise series B.

Why are consumer hardware startups hard?

- Consumers have high expectations and want high quality products from the get go.

- Quality products are incredibly capital intensive, resulting in much shorter runways.

- Building a quality product often times means partnering with an expensive design firm + hiring the engineering talent to back it up.

- Margins are much lower than a typical SAAS. This makes it less appealing for VCs than a pure software play.

- Scaling hardware is harder than scaling software. Lead times are long. The right decisions have to be made ahead of time. Any missteps or problems with your suppliers will delay your launch. If this happens around Black Friday / Christmas -- it's a big deal.

- Not only do delays impact your sales, they will also delay fundraises for much needed cash infusions.

Electric Objects | Senior Full Stack Engineer | Alphabet City, NYC | ONSITE

Electric Objects (https://www.electricobjects.com/) is pioneering digital art in the home. We’re a small and growing group of digital art enthusiasts with a wide spectrum of expertise.

We're looking for a full stack engineer to join our growing team. You will work on our website and the APIs that power the EO1 and EO2 digital art displays. You'll also work on the online store where we sell and explain the EO to the world.

Here's some technologies we use:

- Elixir & Phoenix

- Vuejs

- Ruby on Rails

- PostgreSQL and Redis for data storage.

- We deploy into AWS and Heroku.

To apply click here: http://electricobjects.applytojob.com/apply/TH9KIZQpea/Full-...

If you have any questions, feel free to email me at chris@electricobjects.com

Javascript's async feels a bit more natural than Python's.

In Python, you've also got to run the event loop and pass the async function to it. This makes playing with async code in the interpreter more difficult. Also don't forget that async is also turtles all the way up (same as in JS). It'll infect any synchronous code that touches it.

I've written a Tornado app which makes heavy use of asyncio, and while it's pretty efficient, I would reconsider writing it the same way if I had to go back in time.

I'm working on a project like this as well!

Still in the early stages -- I just got my parts. I'm planning on using the ESP8266 chip + Arduino core (https://github.com/esp8266/Arduino) controlled with a simple web-app.

There's a handy library for doing the Chromecast style wifi setup here (https://github.com/tzapu/WiFiManager).

I see this pattern all the time on GitHub. A promising project starts to catch a lot of stars. Issues start piling up, and the developer no longer looks forward to working on the project because of they have a boatload of issues to deal with first.

An issue is much like an email. Closing an issue requires communicating with (sometimes unreasonable) people. Furthermore, when issues start piling up, critical issues are hidden alongside less important ones making it even more difficult to prioritize.

One way of dealing with things is to maintain inbox zero. Take action right away - delegate, archive or save for a later date. This won't work forever though as your project's userbase grows.

Two high quality libraries with benevolent dictators handle issues very differently:

Peewee (coleifer): https://github.com/coleifer/peewee/issues

Tornado (bdarnell): https://github.com/tornadoweb/tornado/issues

While I haven't had a chance to use 3.5's async/await syntax, I have used AsyncIO pretty heavily to deal with multiple sensor inputs/outputs on a Raspberry Pi.

The author is right. If you write a coroutine, any code that uses it must also be a coroutine. This is pretty annoying when you're trying to test something manually. It bubbles up this way until you eventually hit the event loop.

If you're trying to debug a coroutine in the interactive shell you've got to do something like this:

  loop = asyncio.get_event_loop()
  # Blocking call which returns when the hello_world() coroutine is done
  loop.run_until_complete(hello_world())
  loop.close()

That's my main beef with it. Debugging can also be painful because when you hit an exception, your stack trace will also involve the asyncio library. Aside from those complaints, I'm a fan. It works fine and reads better than callback-style code.

SQLAlchemy is great, but for those who are looking for something lighter, I highly recommend Peewee (https://github.com/coleifer/peewee). It's a very well maintained alternative.

Here's a link to the video of Nate Lewis' talk:

https://www.youtube.com/watch?v=9yNj1zEh-nM

I haven't read Rob Walling's book, but I found his video on "Finding your flywheel" to be useful:

https://vimeo.com/47465229

Thanks for clarifying. This is a very neat way of removing what would be an extra level of nesting.

It doesn't look like native promises support this unfortunately: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refe...

Another nitpick I have with native promises is that they require an extra level of nesting to get the resolve callback.

    // How it is now
    new Promise(function(resolve, reject) {
        resolve('done');
    });


    // vs. What most libraries implement
    var p = new Promise();
    p.resolve(function() {
        return 'done';
    });

iOS Webkit still has the 300ms click event delay even though Android released a simple fix over a year ago.

To work around this, you'll have to use a library like FastClick (which is not perfect) or write some Javascript to hijack touch events.

I've also run into a number of CSS animation issues which are just bizzare. For example, "position: fixed" doesn't apply when a CSS transform is also applied to an element.

neat!

Great write up! I've been working with maps lately and this was a very interesting read.

I've tried the Leaflet SVG layer and it can become quite slow when loaded with thousands of points.

Another approach would be to use a custom SVG layer overlay using CSS Transforms. I've used an SVG overlay with D3 and it was much faster at panning and zooming. It could handle ~30k points (and lots of lines) without a problem on my laptop.

Edit + an example: http://i.imgur.com/ey8YDWJ.jpg

Isohunt.to is an unrelated clone of the original.

Source: used to work for Isohunt.

> 4) My own project, http://hexayurt.com can _always_ use bright sparks!

Very neat. Thanks for sharing!

Would this be a hardware cache + proxy that's specific to a particular app?

This is a great collection of projects. Thanks!