Notes from 9–15/9
The members of a team may increase arithmetically, but teamwork increases geometrically. With each new person comes more than one new interpersonal dynamic, more than one new opportunity for fresh ideas and new angles. And groups usually make better, more careful decisions than their members would have individually
Graph algorithms are often used for feature engineering, to create new predictive elements for training models with the goal of increasing accuracy, precision, and recall rates. Using graph algorithms, we can assign categories based on relationships, calculate centrality, or measure relationships to node data. We can then extract these labels, scores, and measures to feed into machine learning tasks.
MIT AI Ethics Education Curriculum: An Ethics of Artificial Intelligence Curriculum for Middle School Students
Truly amazing, how something so complex can be made so simple
The entire course content is made to be step-by-step and broken down so it’s extremely understandable and operational
A recent paper proposes adapter modules which provide parameter efficiency by only adding a few trainable parameters per task, and as new tasks are added previous ones don’t require revisiting.
The proposed adapter model adds new modules between layers of a pre-trained network called adapters. This means that parameters are copied over from pre-training (meaning they remain fixed) and only a few additional task-specific parameters are added for each new task, all without affecting previous ones.
As you can see in the left of the figure, the standard Transformer is used with an additional adapter layer, added after each sub-layer and before adding the skip connection back. The output of the adapter layer is then forwarded to the layer normalization.
The adapters project the original feature size to a smaller dimension and then projects them to the original size thereafter, ensuring that the number of parameters stays substantially small as compared to the original model (procedure shown on the right of the figure). With the reduction of parameters, there is an obvious trade-off between performance and parameter efficiency which is discussed in the experiments below.
I must say, this is a great attempt. But is it so much better than Bitcoin? And is it truly proven?
I’m starting to think that compleity makes people turn away from blockchain in general. Also the needs do not really resonate with most people. Companies that exist won’t want to just pack up and jump onto YOUR blockchain either.
Possibly the next Bloomberg but for DeFi
Visual Programming — this looks legit nice
This is why microservices emerge as companies grow. With a microservices architecture, an application is made up of independent components that run each application’s processes as a service. Services are built for business capabilities, such as an online shopping cart, and each service performs a single function. It runs independently and is managed by a single development team, so each service can be updated, deployed, and scaled to meet the demand for specific functions of an application. The shopping cart, for example, can support a much larger volume of users when there’s a sale.
Modern applications are built with decoupled data stores in which there is a one-to-one mapping of database and microservice, rather than a single database. This is an important shift from a traditional application architecture, because just as a monolithic application poses scaling and fault tolerance challenges as it grows, so does a database. Plus, a single database is a single point of failure, and it’s hard for a single database to meet the specific needs of a set of varied microservices. By decoupling data along with microservices, you free yourself to choose the database that best fits your need.
It’s all here https://www.youtube.com/watch?v=_a5j7KoflTs
Old-school: JQuery but when the interactions get complicated it gets really messy
To implement a best practice (Command Query Responsibility Segregation) where reading and writing are done separately
You can hack that into the frameworks but it’s not really good.
Event bus with a 1-way binding through a state handler:
Or the flux pattern, Redux:
Explicitness of state mutation is achieved by the following:
- state can only be mutated through dispatcher, instead of arbitrary “state-handlers”
- to make the dispatcher to mutate the state, the only way is to emit an action
- so conclusively, for a View to mutate a piece of state, the only way is to emit an action (or Redux-ly speaking, dispatch an action)
Doesn’t really cover much, but essentially
netlify dev is your development server and there’s a js library that let’s you interact with airtable easily
When you focus on the whole you create a more supportive, diverse group, with a much broader range of skills and knowledge.
At the risk of oversimplifying, the committee recommends:
- Greater specification of tasks, and
- Alignment of incentives with accomplishment of those specified tasks.
But it’s not so good. It alienates.
So here’s the deal:
- Do what’s important- know important vs urgent
- Keep the team informed — have specific protocols for important information
- Make less work for others — understand what others do, take the initiative to help out
- Keep your word — avoids false expectations, don’t break a commitment
- Just keep going — even when things don’t work out
the purpose of experiment is to create knowledge
The red flags and magic numbers that investors look for in your startup’s metric — 80 slide deck included
It was truly an amazing read
To summarise, it’s about placing the prompt at locations where users need it the most can receive it at the time they are about to use it or when it is relevant.
In today’s product companies, the team is more connected and engaged through Slack and other group messaging apps. Conversations are happening, but it takes additional practices and tools for them to be effective. Across the company you need practices for what should be read and replied to, how decisions are documented, knowledge is captured and tasks are tracked.
And for Product Management, how to:
- Turn conversations into insight
- Turn conversations into plans
- Turn conversations into actions
- Turn conversations into continuous improvement
Product Managers, if you takeaway one thing from this post — get out of your spreadsheet and make time for more customer conversations, and think through the cadence of conversations with your stakeholders.
If I had this for DW everything would be so much easier right now
Just all round useful
Small and a great start, already useful! Bubble seems great, but I prefer Glide for now
Just a good quickstart, keeping to share