Oi, sou eu de novo, rs.

Primeiramente, FELIZ ANO NOVO!

Pensaram que eu tinha desistido, mas foi apenas uma pausa por diversas razões. Assim que eu completei o 30º dia, algumas obrigações acadêmicas se tornaram urgentes, as do trabalho também e eu quase acabei ficando igual o gif a seguir e nem as atualizações dos dias eu trouxe.

Achei importante antes de retomar os códigos vir fazer o texto do que aconteceu até o fim de novembro com os primeiros 30 dias. Gostaria de dizer também que desistir não está entre as opções, pode acontecer de eu parar uns dias por conta da rotina e depois retomar, mas desistir não está entre as opções da minha vida nesse momento, por isso, voltei na outra faculdade e peguei meu diploma inclusive.

Nesses últimos dias, eu revi um pouco dos conceitos de iniciais de Orientação à Objetos como classes, métodos, construtores e pacotes. Lembrei o quanto eu preciso praticar e reforçar muito ainda isso, algumas coisas meio que se perdem quando a gente não pratica, mas com a base boa e sólida que tive com alguns dos meus professores, também sou gentil comigo a ponto de perceber que eu realmente aprendi, só preciso me manter praticando os conceitos.

Enfim, dó pra dizer pra vocês que vou retomar de onde parei e que vai demorar um pouco mais pra acabar, mas sigo na luta de melhorar meus conhecimentos de JAVA.

Beijos

The post 100 dias de JAVA: Dias 21 a 30 appeared first on ProdSens.live.

The title is not a clickbait. There exists an actual ‘??’ operator in JavaScript known as the Nullish coalescing operator. This operator accepts operands on either side and returns the right0hand side operand only when the left-hand side operand is strictly falsy or a nullish value. This operator is absolutely a newer one and it was introduced during ES2020 to JavaScript.

falsy and nullish. Aren’t these the same?

No. A value is considered falsy if it coerces to false when evaluated in a boolean expression. In this regard, the following values are considered to be falsy

null - Absence of any object value or a direct null is falsy
undefined - Variable that hasn't assigned any value is falsy
false - The boolean false is falsy
0 - The integer 0 is falsy
-0 - The integer negative 0 is falsy
"" - An empty string is falsy
NaN - Not a Number is falsy

So, what is considered nullish in JavaScript?. Values that are either null or undefined are nullish in JavaScript.

Before getting hands-on with this operator, we should understand the working of short circuit operators.

Short circuit operators

Short circuit operators are basically ‘Logical AND’ && and ‘Logical OR’ || operators. They are used to perform concise conditional logic.

&& operator

Syntax: expression1 && expression2

• returns expression1 if it is falsy and expression2 is not evaluated at all

• returns expression2 if expression1 is truthy(anything other than a falsy value)
  Take a look at this example

// Case when the '&&' returns expression1
const number = 0 && 100
console.log(number) //0 because number1 i.e., expression1 was falsy and JavaScript never had a chance to execute expression2
---------------------------------------------------------------------------------------------------------------------------------
//Case when '&&' returns expression2
const heroes = 'IronMan' && 'CaptainAmerica'
console.log(heroes) //'CaptainAmerica' as string1 which is on the left hand side of the && operator is true, it has returned string2 from the right hand side.

|| operator

Syntax: expression1 || expression2

• returns expression1 if expression1 is truthy

• returns expression2 if expression1 is falsy
  Simple as that.
  Example:

//Case when expression1 is being returned
const heroes = 'IronMan' || 'CaptainAmerica'
console.log(heroes) // 'IronMan' because 'IronMan' is a truthy value
------------------------------------------------------------------------
//Case when expression2 is being returned
const number = 0 || 100
console.log(number) //100 because Number 0 is a falsy value

The ‘??’ operator

In addition to the && and || there exists another operator called as the Nullish Coalescing Operator. This operator is moreover, like a special case of the logical OR operator and its operation is similar to that of the || operator.

As the || operator returns the right-hand side expression when the left hand side is falsy, the Nullish Coalescing operator ?? returns the right-hand side expression only when the left-hand side operand is either null or undefined. So, the ?? operator is more strict than the existing || operator.
Syntax: expression1 ?? expression2
The ?? operator returns expression2 only if expression1 is either null or undefined. Meanwhile, expression1 is returned if it is simply any value other than a nullish value.

//Case 1
const number = 0 ?? 100
console.log(number) //returns '0' because it is not nullish
------------------------------------------------------------
//Case 2
let fruit = ''
let veggie = 'Carrot'
const basket = fruit ?? veggie
console.log(basket) // '' because an empty string('') is not nullish but falsy
------------------------------------------------------------------------------------
//Case 3
let halves = 'fullPortion' / 2
let full = 1
const portion = halves ?? full
console.log(portion) // NaN. Obtained by the evaluation of the left hand side expression and it is not nullish but falsy.
----------------------------------------------------------------------------------------------------------------------------
//Case 4
let hero1
let hero2 = 'CaptainAmerica'
const heroes = hero1 ?? hero2
console.log(heroes) // 'CaptainAmerica' because 'hero1' is undefined

The ?? operator is designed in such a way that it cannot be used along with the && and || without proper brackets.

null || undefined ?? 'hi' // SyntaxError: missing ) after argument list

(null || undefined) ?? 'hi' //'hi'

But why them?

This question arises as soon as we see some unfamiliar syntax that makes some work. Can’t we just stick with the classic if else statement to quantify expressions? Yes we can, but No. Let me explain why is that.
We can use if else conditions as long as we use plain JavaScript. But when it comes to using frontend UI libraries like ReactJs, it is impossible to embed if statements within the JSX structure they return. We should use only expressions that use logical operators in this regard. Confused about expressions and statements? Scroll down to the bottom and you can find the relevant resource.

This is not the only use case. But they avoid unnecessary execution of expressions with a single line of code.

You are open to construct a more complex logic using short-circuit operators as follows:

const gameConfig1 = { 
 playerName: 'John',
 score: 22500,
 highScore: 35000,
}
const gameConfig2 = { 
 playerName: undefined, 
 score: undefined,
 highScore: undefined
}
function getPlayerInfo( player ){
 const { playerName, score, highScore } = player
 const currentPlayerName= playerName ?? 'Guest'
 const currentPlayerScore = ( score >= 100 && score ) || 'No scores yet'
 const currentPlayerHighScore = highScore ?? 'No high scores yet'
 return { currentPlayerName, currentPlayerScore , currentPlayerHighScore }
}
const player1 = getPlayerInfo( gameConfig1 ) // { name: John, score: 22500, highScore: 35000 }
const player2 = getPlayerInfo( gameConfig2 ) // { name: 'Guest', score: 'No scores yet', highScore: 'No high scores yet' }

That’s all about the Nullish coalescing operator. Practice more to get familiar with this operator. It may take some to do so, but it’s worth the time you spend.
Following is the article distinguishing between Expression and Statement in JavaScript

Statement vs Expression – What’s the Difference in Programming?

Learning the syntax of a programming language is key if you want to use that language effectively. This is true for both new and experienced developers. And one of the most important things to pay attention to while learning a programming language is whether the code you’re dealing with is

freecodecamp.org

To know more about the nullish coalescing operator, refer to the following docs by MDN.

Nullish coalescing operator (??) – JavaScript | MDN

The nullish coalescing (??) operator is a logical
operator that returns its right-hand side operand when its left-hand side operand is
null or undefined, and otherwise returns its left-hand side
operand.

developer.mozilla.org

The post Redefine your Logic for stricter, safer JavaScript defaults with the ‘??’ operator appeared first on ProdSens.live.

Web development has evolved significantly over the years, with a constant quest for more modular, reusable, and maintainable code. Web Components provides a set of web platform APIs that enable the creation of custom, reusable, and encapsulated HTML elements.

HTML Templates

HTML Templates are the foundation of Web Components, providing a way to declare fragments of markup that can be cloned and inserted into the document later. This helps in creating modular and reusable pieces of UI.

 id="my-template">
  
   class="component">
    
Hello, !
  

Here, we’ve defined a template with a placeholder () that can be filled with content when the template is used.

Custom Elements

Custom Elements allow developers to create their own HTML elements with custom behavior. They encapsulate functionality, making it easy to reuse and share across different projects.

class MyComponent extends HTMLElement {
  constructor() {
    super();

    const shadowRoot = this.attachShadow({ mode: 'open' });

    // Use the template directly within the class
    shadowRoot.innerHTML = `
      
      
Hello, !
    `;
  }
}

customElements.define('my-component', MyComponent);

Now, you can use in your HTML:

Shadow DOM

Shadow DOM provides encapsulation for your web components, shielding their styles and structure from the rest of the document. This ensures that styles and scripts in your component do not interfere with the rest of the page.

class MyComponent extends HTMLElement {
  constructor() {
    super();

    // Attach a shadow DOM to encapsulate styles and structure
    const shadowRoot = this.attachShadow({ mode: 'open' });

    shadowRoot.innerHTML = `
      
      
Hello, !
    `;
  }
}

customElements.define('my-component', MyComponent);

Tips

1. Keep it modular: Break down complex UIs into smaller, manageable components to maximize reusability.
2. Use Shadow DOM judiciously: Leverage Shadow DOM to encapsulate styles and scripts, preventing unintended interference.
3. Explore component libraries: Many libraries, such as LitElement and Stencil, simplify the creation and management of Web Components.
4. Events: Use Custom Events to establish communication between Web Components, enabling a more modular architecture.
5. Lifecycle Hooks: Implement lifecycle hooks (e.g., connectedCallback, disconnectedCallback) to perform actions when a component is added or removed from the DOM.

Usage

Web Components find extensive use in various scenarios, from UI libraries to large-scale applications.

• UI Libraries: Build modular UI components that can be easily shared and reused across projects.
• Micro-frontends: Use Web Components to create self-contained, independently deployable parts of a larger application.
• Third-Party Integration: Develop widgets or components that can be embedded seamlessly into other websites.

The post Day 93: Web components appeared first on ProdSens.live.

Using applications like ChatGPT requires some care.

Part of the difficulty is that ChatGPT’s human-like conversation abilities can be deceptive. Feeling like you’re talking to a real person encourages you to rely on conversational expectations that may not hold with a machine.

For instance, we generally expect that most people do not make up facts. Large language models, however, routinely violate this expectation by providing fluent answers that may be totally wrong. The metacognitive ability to know what you don’t know is underdeveloped in these applications.

Another expectation we have is that verbal fluency tracks other aspects of intelligence. We expect that someone who can spout lines from Shakespeare, explain quantum computing, and give a proof of the prime number theorem in rhyming verse would also be able to count. Thus, naively treating LLMs like a really smart and knowledgeable person is likely to backfire.

Those caveats aside, ChatGPT is clearly helpful for a range of tasks. Simon Willison suggests thinking of LLMs as a “calculator for words” — something that can do useful things with text — rather than as a general-purpose intelligence or smart person.

I tend to agree. The more we can distinguish the cases where LLMs work well from where they don’t (yet), the more we’ll be able to take advantage of the new capabilities without falling into unexpected traps.

Ten Useful Learning Strategies with ChatGPT
After receiving dozens of emails from my readers on how they have been personally using ChatGPT to learn, I’ve compiled some tips with some of the most common suggestions.

1. Create your own Socratic tutor.
By far, the most common use readers reported was using an LLM as a personal tutor.

Asking ChatGPT to explain tricky concepts, unfamiliar code or problems seems like an area where LLMs might do alright. And the only reasonable substitute (a human expert) is notoriously expensive and in short supply.

If you do this in conjunction with a class or textbook, the risks of mistakes also seem attenuated since you still have a primary source to compare against. Challenge explanations that don’t jive with what you’ve read in the book rather than taking everything the AI says at face value.

2. Practice chatting in new languages.
The next most common way people used LLMs to learn better was as a language tutor. This seems like a task LLMs are well-equipped for. Whatever their other flaws, they can produce grammatically correct text.

Many people set up their conversations with ChatGPT so that the AI could go back and forth between the language they are learning and English explanations when they got confused. Likely, those explanations may be imperfect, but human tutors also often give incorrect accounts of the grammar and vocabulary they manage to use proficiently.

Another use is rewriting texts to be at a more beginner-friendly level of reading comprehension. Graded readers and comprehensive input are great strategies for learning to read in another language. Unfortunately, learner materials are often sparse or uninteresting. You can use an LLM to transform a text you want to read that is written at a fluent native level into something appropriate for your current ability.

Duolingo seems to be getting in on the LLM game as well. I’ve been harsh on the drag-and-drop style of language learning used in earlier versions, but these new advances may force me to revise my opinion.

3. Generate summaries of longer texts.
Summaries are another area where LLMs seem to excel. Consumer applications already exist for generating summaries of journal articles or research topics.

Several readers said they were using these AI tools to provide digests of their substantial reading material, helping them keep atop new developments in their field.

Good summaries, especially those fine-tuned to your particular needs, might be a good way of navigating the large information loads we often face in knowledge work. You could use it to help prioritize which documents to read in-depth or do a first pass organizing unfamiliar material.

4. Dialog with long documents.
LLMs also can help you “ask questions” of longer texts. For instance, when reading a scientific paper you could quickly query the sample size or ask for the methodology or results. Consensus does this while offering references, so the risk of mistakes seems reduced when you can easily double-check the LLM’s work.

While there are more fanciful usages here, such as people asking ChatGPT to impersonate a given writer and dialog with them, I suspect the ability to ask natural-language questions of documents and receive replies with references is a useful tool for dealing with large texts.

That said, you must be prepared to fact-check the LLM’s answers. For instance, in the dialog captured below, I asked ChatGPT to list evidence supporting strongly-guided instruction, and it cited a review article by Mayer. But it falsely claimed Mayer’s work was a meta-analysis, which it isn’t. In fact, the paper isn’t even a comprehensive literature review but simply looks at three prominent cases of the failure of discovery learning. If taken at face value, this response can potentially mislead, but it’s relatively easy to “check” the AI’s work if you know what text it is transforming.

5. Rewrite texts at different levels of explanatory depth.
A major difficulty in following expert thinking is that most expert-level text is written for other experts. Concepts are unexplained, context is lacking and jargon abounds. This means that most people must rely on translators, such as general-market nonfiction or science writers, who present what experts think in a more readable format.

There seem to be two approaches to using AI tools here. One is simply asking an LLM to explain a popular concept in simpler terms, such as: “Explain quantum computing like I’m an eighth-grader.” The other is to provide ChatGPT with a text or explanation and ask the AI to rewrite it in a more digestible manner.

I tend to think the latter is a little more reliable since you have the source material to compare with rather than taking ChatGPT’s word for it.

6. Clear up unfamiliar jargon.
Several years ago, I remember reading Tyler Cowen’s Marginal Revolution blogand being perplexed by his frequent, unexplained use of the term “Straussian” to describe ideas or other thinkers. I Googled for an explanation, but none was forthcoming.

After a lot of research, I understood the term as meaning, roughly, “closely reading between the lines in prominent thinkers’ ideas, looking for what they really meant but couldn’t always express because of prevailing censorship and intellectual orthodoxy.”

Had ChatGPT existed during my confusion, I could have just gotten this:

Many readers found similar benefits in using LLMs to figure out jargon and terms used within a particular community in a way that dictionary definitions often fail to elucidate.

7. Create study plans and agendas.
This usage surprised me, but it showed up enough times among reader replies that I include it here. People seem to like using AI to tell them how and when to learn.

For instance, some readers asked ChatGPT to break down a complex learning goal and give them a curriculum. Others preferred to go even further, asking for ChatGPT to create a studying schedule for them, given their constraints for the day.

I probably wouldn’t trust LLMs to give me a well-designed curriculum for a subject. But if I was learning something completely new, it might be a decent starting point. Sometimes the hardest part of approaching a new field is breaking down what appears to be an insurmountable goal. Similarly, sometimes being told when to study can help overcome the inertia of getting started.

While skill breakdowns might be alright, ChatGPT still struggles with creating reading lists, confabulating books and references. Thus, while it might do well for decomposing an ambiguous learning task, I wouldn’t trust it to give me good resources (yet).

8. Provide refreshers on forgotten or infrequently used tools.
Programmers were the biggest professional group to reply to my query. I can’t say whether this is because programming is uniquely well-suited to LLMs or because programmers, as a group, are more likely to adopt novel software tools.

The productivity advantages for programmers seem obvious. I don’t write much code these days, so I haven’t made much use of this well-publicized feature of LLMs. But since a lot of coding is relatively routine, the ability to have a machine create the first draft for an algorithm clearly saves a lot of time.

While there are cases of people with zero programming knowledge relying on AI output to build applications, I suspect these might be tricky to debug and maintain. In contrast, an expert programmer can override ChatGPT’s output for a language he or she knows particularly well.

The place LLMs seem to work really well is at the fringes of a programmer’s expertise. Many programmers told me that they found AI helpful in getting starting hints in unfamiliar languages or tools. Their base of programming experience allowed them to make sense of and implement the output, but their unfamiliarity with the underlying language meant the AI saved them a lot of time.

9. Generate flashcards based on text. (Tentative)
Flashcards are a powerful learning tool. They’re also a pain in the butt to make.

Some readers said they were using ChatGPT to generate flashcards for subjects they’re studying. This seems well within the LLM abilities as a “calculator for words.” Thus, with the correct prompts, you could get fairly good results here — provided you’re inputting the material you wish to see transformed into flashcards and not expecting the LLM to get the facts on its own (see below).

However, given the difficulty of making “good” flashcards, I wouldn’t enter any into my Anki without reviewing them first. Nonetheless, making flashcards is tedious, so getting a first draft that I later review might speed up the process considerably. The risks seem relatively limited if you confirm the cards’ correctness before putting them in your deck.

10. Use it to organize your notes. (Advanced)
As someone who does a lot of research, I often waste a lot of time trying to locate my notes. Robert Martin finds the same problem. Searching via keywords is fraught because sometimes you can’t remember the exact term you used, even if the meaning is roughly the same.

Martin solves this problem by using the embedding feature of LLMs. While not strictly ChatGPT, this tool from the same family of natural language processing techniques allows you to find semantically-related notes rather than exact keyword matches.

Personalized LLMs that live on your hard drive and access your existing data may be a valuable application. I’d love to be able to search things I know I’ve seen but can’t quite recall where.

Some Things NOT To Do

1. Don’t expect AI to get facts right.
2. Don’t expect AI to get citations right.
3. Don’t expect AI to get the math right.

The post 10 Best Ways To Use ChatGPT (With Examples) appeared first on ProdSens.live.

Introduction

As a JavaScript developer, you know how important it is to stay up-to-date with the latest language features and tools. That’s why ES6 (also known as ECMAScript 2015) is such a game-changer. With its powerful new features and improved syntax, ES6 has revolutionized modern JavaScript development. But with so many new additions to the language, where do you start?

In this post, we’ll walk you through the most essential ES6 features that every JavaScript developer should know. From block-scoped variables to template literals, we’ll show you how these features can make your code more concise, readable, and maintainable. So whether you’re a seasoned JavaScript pro or just starting out, get ready to take your skills to the next level with ES6!

1. Block-Scoped Declarations

In JavaScript, block-scoped variables can be declared using let and const keywords. Block-scoped variables are only accessible within the block of code they were defined in. This means that if a variable is declared inside a block of code, it cannot be accessed outside that block. This feature of JavaScript allows developers to write more secure and predictable code, reducing the chance of variable name collisions.

The let keyword is used to declare block-scoped variables that can be reassigned later. In the following example, we declare a variable x outside an if block and assign it the value 10. Inside the if block, we declare another variable x and assign it the value 20. When we log the value of x inside the if block, we get the value 20. However, when we log the value of x outside the if block, we get the value 10. This is because the variable x inside the if block is a different variable than the one declared outside the block.

// Example of let
let x = 10;
if (true) {
  let x = 20;
  console.log(x); // Output: 20
}
console.log(x); // Output: 1

The const keyword is used to declare block-scoped variables that cannot be reassigned. In the following example, we declare a constant PI and assign it the value 3.14159. When we try to reassign the value of PI to 42, we get an error because we cannot reassign a constant.

// Example of const
const PI = 3.14159;
PI = 42; // Throws an error

2. Arrow Functions

Arrow functions are a new syntax for creating functions in JavaScript. They provide a concise way to define functions and are often used in conjunction with other new features of JavaScript like let, const, and template literals. Arrow functions have a shorter syntax than traditional functions and provide a few benefits over them.

The syntax for an arrow function looks like this: (arguments) => { expression }. The arrow function can take zero or more arguments, and the function body is a single expression. If the expression is a single statement, it does not require curly braces.

In the following example, we define a traditional function add that takes two arguments and returns their sum. We then define an arrow function add that does the same thing. The arrow function is shorter and more concise than the traditional function.

// Traditional function
function add(a, b) {
  return a + b;
}

// Arrow function
const add = (a, b) => a + b;

// Arrow function with multiple statements
const sayHello = name => {
  const message = `Hello, ${name}!`;
  console.log(message);
};

3. Template Literals

Template literals are another new feature of JavaScript that allows developers to create strings more easily. They provide a way to include variables and expressions inside a string without having to concatenate them using the + operator. This makes code more readable and easier to write.

The syntax for a template literal is a string enclosed in backticks. Inside the string, we can include variables or expressions by wrapping them in ${}. In the following example, we define a variable name and a string message that includes the variable using a template literal. This is equivalent to concatenating the string using the + operator.

const name = 'John';
const message = `Hello, ${name}!`;
console.log(message); // Output: "Hello, John!"

We can also include expressions inside a template literal. In the following example, we define two variables and use them in a template literal to create a string that calculates the sum of two numbers.

const a = 10;
const b = 20;
const sum = `${a} + ${b} = ${a + b}`;
console.log(sum); // Output: "10 + 20 = 30"

Template literals also support multi-line strings, which can be useful when working with long strings of text. In the following example, we define a variable that includes line breaks using a template literal.

const text = `This is a
multi-line
string.`;
console.log(text); // Output: "This is anmulti-linenstring."

4. Destructuring

Destructuring is a new feature of JavaScript that allows us to extract values from objects and arrays and assign them to variables. This can simplify code by reducing the need to write verbose code to access properties of objects or elements of arrays.

Destructuring Objects

To destructure an object, we can use the following syntax:

const person = { name: 'John', age: 30 };
const { name, age } = person;

In this example, we create an object called person with two properties: name and age. We then destructure the object using curly braces {} and assign the values of the name and age properties to variables of the same name. The resulting variables will have the values 'John' and 30, respectively.

Destructuring Arrays

To destructure an array, we can use the following syntax:

const numbers = [1, 2, 3, 4, 5];
const [first, second, ...rest] = numbers;

In this example, we create an array called numbers with five elements. We then destructure the array by assigning the values of the first and second elements to variables called first and second, respectively. We also use the rest parameter syntax ... to assign the remaining elements of the array to a new array called rest.

5. Classes

• Explanation of class syntax and how it simplifies object-oriented programming in JavaScript
• Code examples of classes in Markdown format:

// Example of a class 
class Person { 
    constructor(name, age) {
     this.name = name;
     this.age= age;
    }

    sayHello() {
        console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
}
}
const john = new Person('John', 30);
john.sayHello();

Conclusion

In conclusion, we’ve covered some of the most useful ES6 features that can make your JavaScript code more efficient, readable, and maintainable. From destructuring to arrow functions to classes, these features can help you write code that’s not only faster to develop but also easier to debug and extend.

But don’t stop here! ES6 is a vast and constantly evolving language, and there’s always more to explore. So keep experimenting with new features, read the official documentation, and join online communities to learn from other developers. With ES6 in your toolkit, you’ll be well-equipped to tackle any JavaScript project that comes your way. Happy coding!

The post 👨🏽‍💻🚀 Discover These 5 Incredible ES6 Features That Will Make You a Better JavaScript Developer 🚀👨🏽‍💻 appeared first on ProdSens.live.

We have to start learning somehow, so why not in a challenge?

Table Of Contents

• 1. Introduction
• 2. The Challenge
• 3. The Content
• 4. Final Considerations

1. Introduction

Hey everyone! I’m Daniel Reis, 23yo Brazilian, and I want to learn more about C++, Rust and Database Paradigms. But the thing is: I’m already developing stuff since 2011, when I first wrote my first line of code of PawnLang to run a GTA SA:MP server.

So you’re should be thinking: why I entered on the #100daysofcode challenge? Very simple: I’m a newbie in a lot of technologies and concepts. I focused all this time to learn PHP and Laravel, Linux and other stuffs to get a job and enter the market but now I have a new challenge to move on.

So, even a “Senior” will be a “Junior” sometimes and it is more common than you think. Anyways, my focus will be learning everything and share it on my Twitter and try it to post daily here. Hope that I can finish the #100daysofdevto too LOL.

Daniel Reis

@danielhe4rtless

I’m publicly committing to the 100DaysOfCode Challenge starting today! What I’m going to learn more about on these days:

– Database Paradigms
– C++, Rust and PHP
– Content Creation in English

Hope that you folks like it
hey @ka11away 100DaysOfCode.com #100DaysOfCode

20:33 PM – 20 Feb 2023

2. The Challenge

The #100daysofcode is a challenge using Twitter Hashtags to seal a commitment that you will study 1 hour every day for 100 days in a row.

The topic that you will study is up to you to decide. My idea here is to use it improve skills that I will need to the next steps on my carrier, such as:

• Learn about Database Paradigms and create content about it;
• Learn about C++ enough to read some huge projects on Github;
• Learn about Rust because this lang will be the future.

With that, produce all the content possible for the community, focused on beginners friendly explanations and help many people as possible.

3. The Content

Daniel Reis

@danielhe4rtless

Day 1 #100daysofcode

I decided to start learning about C++ first, but first I had to setup the enviroment.

Since I’ll be using the VS Code to do everything, I found this plugin that will help me on my journey.

PS: if you’re using WSL2 remember to download it inside of it.

22:20 PM – 20 Feb 2023

That’s my first day of the challenge, and I learned the basics about C++ because it seems easier to learn than Rust in a first moment.

I had a tough time trying to build the environment on WSL because I was not event connected on the Linux env where the compiler was (total dumbass) but I saw the problem minutes after and it worked!

My goal to understand the structure of a “Hello World” program in minimal details was enough for today, so let me explain it for you.

• You can call libraries in cpp using #include
• Every C++ project HAS to be a function called main()
  • Main is a function, so don’t forget the parenthesis ()
• About the std::cout << "@danielhe4rtless" << std::endl;
  • std:: is a abbreviation to standard
  • std:: is a namespace, which means that inside the std:: has other functions awaiting to be used such as endl (end of line).
  • We have the << operator, that tells your compiler that it will read your line from the end of the line until the start.
  • We use the the semicolon ; to tell our compiler that this specific line of code is over and it can read the next one.
• You can compile using a binary called g++ and you can install it easiliy on Linux.

4. Final Considerations

It was a long day streaming and learning concepts so if you liked my initiative please join me on the challenge! It will be a cool idea to be with more people through this process.

Don't forget to stay hydrated and see you tomorrow's daily post!

Follow me on Twitter: @danielhe4rtless
Follow me on Github: @danielhe4rt
Follow me on Twitch (daily livecoding sessons now in English): twitch.tv/danielhe4rt

The post Challenge Accepted: #100DaysOfCode appeared first on ProdSens.live.

¡Hola!

Despues de varios meses planeando como voy a empezar a retomar la programación por fin me anime a repasar el bootcamp de soyHenry.

Es difícil comenzar a estudiar de nuevo porque al ya conocer lo que estas viendo genera aburrimiento y falta de motivación, encontré este reto por ahí y me gusto bastante el formato.

El primer paso es lo más dificíl

Comenzar es la parte más importante del proceso, lamentablemente al tener tantas opciones diferentes para hacer lo mismo y tanta información a la mano, es complicado saber por donde tomar cualquier tema.

Te recomiendan empezar por las cosas que te gustaría hacer, no necesitas anotar que librerias o frameworks usaras lo cual es bueno.

En mi caso me gustaria hacer un blog de tecnologia con el estilo de medium combinado con dev.to y ahi subir los proyectos que desarrolle y cosas que se me hagan interesantes, más que nada para mantener la motivación de aprender a programar y poder en el futuro trabajar de desarrollador.

¿Cómo lo conseguire?

En mi caso seguire la ruta que te da el bootcamp de soyHenry para aprender de nuevo las bases y despues comenzare a hacer proyectos siguiendo tutoriales.

¿Y ahora?

Es todo por ahora! en el proximo blog debería comenzar a tomar los apuntes de las cosas que se me hagan más interesantes y no te preocupes, intentare escribirlo para que hasta un niño de 4 años lo entienda.

PD: ya había tomado el bootcamp y me gusto mucho, si estas buscando aprender de desarrollo esta es una gran opcion!

The post Empezando el Bootcamp de soyHenry💛 #100DaysOfCode appeared first on ProdSens.live.

Today’s Lesson

This article should be short and sweet. There weren’t any assignments for this day so It didn’t take me as long as the previous days.

We pretty much just discussed functions and while loops as well as touched on the importance of indentation.

While loops in Python are still a bit confusing for me so I won’t go into detail or try to explain the concept like It clicked for me the first time through. For the day’s project, we used Reeborg’s World for the challenge. The objective was to lead him to the finish by using while loops and if statements. My solution is below.

https://reeborg.ca/reeborg.html?lang=en&mode=python&menu=worlds%2Fmenus%2Freeborg_intro_en.json&name=Maze&url=worlds%2Ftutorial_en%2Fmaze1.json

EOD

Like I said, today was pretty short and sweet. I’ll probably have to go over this lesson again or see if my other course can explain this concept in more detail for me.

See ya tomorrow .

If you want to keep up with my progress or just want to connect as peers, check out my social links below and give me a follow!

• Twitter
• Github
• Discord
• LinkedIn

The post Day 6: Python Functions & Karel appeared first on ProdSens.live.