I agree with the general premise of avoiding premature optimizations, but designing systems that scale is important for several reasons:
- Startups grow exponentially, if you're playing catchup as you're growing you are focusing on keeping the lights on and hanging on for the ride. Important for a growing company to focus on vision.
- Software that scales in traffic is easier to scale in engineering effort. For example, harder for a 100 engineers to work on a single monolith vs 10 services.
- Service infrastructure cost is high on the list of cash burn. Scalable systems are efficient, allow startups to live longer.
- If the product you are selling directly correlates to computing power, important to make sure you are selling something that can be done profitably. For example, if you are selling video processing as a service, you absolutely need to validate that you can do this at scale in a profitable manner.
I also don't agree with the premise that speed of development and scalable systems are always in contention. After a certain point, scalable systems go hand and hand with your ability to execute quickly.
In the projects that I was involved in in the past years, the ones that decided to build a scalable infrastructure before gaining traction were exactly those that were burning cash on infrastructure. There is just a reasonable minimum of servers you need to run such an infrastructure and then you need something similar as a staging environment to make sure it all works together correctly.
That being said, there are of course choices that can be made early on that will help you in case you need to scale at some time. Spending a bit of time thinking through what would happen if you do need to split up and scale out your system will help you avoid pitfalls such as relying too much on the local filesystem being shared across pageviews.
In general I believe there is more benefit on spending time on performance early on. (not caching, that is just postponing the problem) as it benefits not just your ability to run on a single system for much longer, it will also make life better for your users.
Scalable system does not imply needing many machines. There is no reason you can't just deploy your entire system on a single host, but maintain the ability to reconfigure exactly when needed.
I think it takes experienced managers and developers with business-oriented mindset to achieve the best compromise. Saying "there is no need to overengineer now" can be as bad as months of overengineering. It all depends on the business.
Agreed, it's terrible. It's amazing there is no plugin for Gradle that does it all for you, including splitting the app for different dpi and arch. Is there a way and it just isn't publicized? AFAIK Google Play does have an API..
Well, they should just be doing it for you on the back-end. In fact, all you should have to do is upload an APK with all high-res assets and google should downsample them as appropriate for the downloading device. But they don't so...
Well, your signing of the package would just be a signature to Google that it was indeed you who uploaded it. Google would then sign the new packages as themselves and the Play store could only download and install Google signed packages.
Android package security (who can send intents to who) is based off of signatures and it's not really possible or desirable to change that.
However, a build script to handle it all for you during upload would be a great way to solve it.
The API for this seems to lack the features that you would need though [1]. It doesn't appear to let you upload apps for only certain devices - unless you would specify it in the manifest of the app somehow?
Also amusing - the API says "Do not supply a request body with this method", yet obviously you'd have to supply a request body - the app itself! I have a feeling this is not a well-used API.
> Also amusing - the API says "Do not supply a request body with this method", yet obviously you'd have to supply a request body - the app itself! I have a feeling this is not a well-used API.
Or Google just doesn't give a fuck. There's various bugs with uploading expansion files that are documented from day one and still unfixed.
I like Heap's (https://heapanalytics.com) approach - capture everything, query later. Depending on your needs (Heap is front-end UI oriented), might not be the right fit.
I don't think it is as simple as learning that you can talk about it - you have to learn who to talk about it too. Not everyone wants to hear that things are not working quite as planned - most people would rather just hear "Great!"
Is there evidence to support that accelerators are pre-selecting based on elite backgrounds? It would be really interesting to see YC's % of founders from Ivy league + Stanford over time.
This is not surprising given British history. Culturally there is an overhanging bias towards credentials and elitism, however I get the strong feeling (as an American Co-Founder living in London the past 2 years) that things are definitely moving in the right direction here. Whereas Silicon Valley with its general west-coast counter cultural history is much more accepting but probably moving in the wrong direction as "startups" are mainstreamed and investors are looking for some signal in the noise of all the wannabes.
As usual though, successful founders must find their own way, and if they are dependent on being given a shot by some gatekeeper they probably never had much chance to be a successful entrepreneur anyway.
What he's saying is that the views you want to be SEO'd can be generated server side and bootstrapped into Backbone (hook backbone views into an element that is rendered server side).
I currently do this too - I'll add that it is helpful to use a templating language that will work both server side and client side so you only write your templates once.
What does become a pain is doing routers/controllers both client side and server side - end up writing some code more than once and in different languages. Harder to maintain, especially when changes are made.
Right, and if you want to generate them server side, you either need to have separate templates for server side and client side, or you can execute the javascript on the server (which is what the OP decided to do).
Noone is saying there aren't other solutions to the problem, but I think the OP's solution met his goals pretty well and I thought it was a neat concept.
- Startups grow exponentially, if you're playing catchup as you're growing you are focusing on keeping the lights on and hanging on for the ride. Important for a growing company to focus on vision.
- Software that scales in traffic is easier to scale in engineering effort. For example, harder for a 100 engineers to work on a single monolith vs 10 services.
- Service infrastructure cost is high on the list of cash burn. Scalable systems are efficient, allow startups to live longer.
- If the product you are selling directly correlates to computing power, important to make sure you are selling something that can be done profitably. For example, if you are selling video processing as a service, you absolutely need to validate that you can do this at scale in a profitable manner.
I also don't agree with the premise that speed of development and scalable systems are always in contention. After a certain point, scalable systems go hand and hand with your ability to execute quickly.