A Genealogy of Technology and Power Since 1500 – collection of main inventions, from the printing press to the chatgpt.

Get hooked on high-quality content right here. 🤔

Why is the Developer Doing Everything? 🤔

Ever feel like you’re the team’s Swiss Army knife, doing everything from coding to setting up the coffee machine?

1. Developer = Jack of All Trades
We code, we test, we even do a bit of design! With a skill set like ours, it’s no wonder tasks keep landing on our plate. 😓

2. Small Team, Big Expectations
In startups, there’s no budget for specialists, so who’s going to handle it all? Yep, you guessed it—us. 💪

3. “Just Give It to the Dev” Syndrome
Without clear roles, everything from bug fixes to Friday night pizza orders ends up being a developer’s responsibility. 🍕

4. Communication Struggles
Sometimes it feels like “the dev will figure it out” is the team’s unofficial motto. 😅

5. Expectations Galore
When you’re a key player, it’s like there’s a neon sign over your head saying “Dump Tasks Here.” 🛑

#DeveloperLife #TechHumor

The GPT-4 model has now been marked as the 'Leagcy model' 🤯

A new 'o1' model has been launched, but it doesn't yet support web browsing, file handling, or image uploads.

Whom it’s for

...o1 can be used by developers in all fields to build and execute multi-step workflows. 👨‍💻

Sam Altman wrote a post about the future of AI — here are the key points:

1. In the next few years 🔜
- AI will become a personal assistant, handling specific tasks like coordinating medical care.
- Virtual tutors will provide personalized learning in any subject and any language.
- Healthcare will improve with AI advancements.
- We’ll be able to create any kind of software on demand.
- Changes in the job market will happen more slowly than people expect.

2. In the next 5 years 😑
- A breakthrough in creating superintelligence (AGI) could happen.
- AI will have a significant impact on the job market, but new forms of work will emerge, even if they don’t look like traditional jobs.

3. Mid-term (a few decades) ✍️
- Personal teams of AI experts will help solve almost any task.
- A rise in global prosperity and a fairer distribution of wealth will become possible.

4. Long-term ⌛️
- AI will accelerate scientific progress and help develop the next generation of AI systems.
- Solutions to global issues like climate change and space colonization are on the horizon.
- We could unlock all the laws of physics and gain access to limitless energy.
- Society will shift toward positive-sum games, with new forms of work that seem unimaginable today.

Big changes are coming, along with challenges, but the future looks exciting! Adapt or be replaced by AI 😐

You've thought you can hide from the Big Brother? Escaping from Matrix getting harder and harder

From Mr. Durov's post

Since 2018, Telegram has been able to disclose IP addresses/phone numbers of criminals to authorities, according to our Privacy Policy in most countries.

🐶BTW, Telegram encryption works only in secret chats, but since they have your IP and phone number, there’s more at play behind the scenes. While secret chats boast end-to-end encryption, standard conversations are stored on Telegram’s servers, accessible by the platform itself. This raises concerns about how secure your data truly is, especially when combined with metadata like your IP address and phone number.

Who has access to this information, and what are they doing with it?
Could these seemingly innocuous details be the key to uncovering deeper insights into your identity or tracking your movements in ways you’re unaware of?

However, you can relax until you are not interesting to the Gov. 🙂

Make a note of that 🤓

Task
You're given an array of integers a and two integers x and y. Count the number of elements in the array such that `x ≤ a[i] ≤ y, where i is the 0-based index of the element.

Seems easy, but:
code limit: less than 48 characters.

This is like an average business task: the task gets solved, but unnecessary stuff always seems to get in the way. 😂

Don't Overthink, Start Solving! 💡

When faced with a complex task, it's easy to overthink and get lost in endless solutions. But here's the key: just start solving!

Once you get the correct result, it's time to optimize.
Bit by bit, refine your code—make it more readable, maintainable, and sometimes even faster (but not always 😉).

Here is an example:

Task is

Implement a function that receives two IPv4 addresses, and returns the number of addresses between them (including the first one, excluding the last one).

All inputs will be valid IPv4 addresses in the form of strings. The last address will always be greater than the first one.

Solution optimizing evolution

First version, which works, but its a big unreadable code

// first version
export function ipsBetweenV1(start: string, end: string): number {
  const reversedStart = start
    .split(".")
    .reverse()
    .map((segment) => parseInt(segment, 10)) as number[]
  const reversedEnd = end
    .split(".")
    .reverse()
    .map((segment) => parseInt(segment, 10)) as number[]

  const amountInStart = reversedStart.reduce((acc, curr, index) => {
    acc += curr * Math.pow(256, index) + 1
    return acc
  })
  const amountInEnd = reversedEnd.reduce((acc, curr, index) => {
    acc += curr * Math.pow(256, index) + 1
    return acc
  })

  return amountInEnd - amountInStart
}

Nasty...

Implementing DRY and Divide-and-conquer:

// second version
export function ipsBetweenV2(start: string, end: string): number {
  const getReversedSegments = (ip: string) => {
    return ip
      .split(".")
      .reverse()
      .map((segment) => parseInt(segment, 10)) as number[]
  }
  const calcAmountInIps = (ips: string) => {
    return getReversedSegments(ips).reduce((acc, curr, index) => {
      acc += curr * Math.pow(256, index) + 1
      return acc
    }) as number
  }

  return calcAmountInIps(end) - calcAmountInIps(start)
}

Looks much better. But something is missing, and looks like we overdoing something...

Removing unneeded reverse(), and simplifying functions into one with readable structure:

export function ipsBetween(start: string, end: string): number {
  const ipToNumber = (ip: string): number =>
    ip.split(".").reduce((acc, curr, index) => acc * 256 + parseInt(curr, 10), 0);

  return ipToNumber(end) - ipToNumber(start);
}

Final solution looks 10 times better, much more readable and well structured 🗣

#CodingTips #ProblemSolving #DeveloperLife

The US has a special commission established in 2000, known as the United States–China Economic and Security Review Commission. The commission consists of 12 members and reports exclusively to Congress. It is not part of any agency or department. Every year, before December 1, the commission publishes a report that, among other things, makes recommendations to Congress.

And the first thing in the new recommendation:

- Congress establish and fund a Manhattan Project-like program
dedicated to racing to and acquiring an Artificial General Intelligence (AGI) capability.

😬 😬 😬


#news #ai