DEV Community: Daniela Lima

Treasure Hunt: 5 Juicy Repos on GitHub

Daniela Lima — Sat, 30 Oct 2021 16:01:33 +0000

(Almost) Everything you need in such a place!

Ahoy matey! During my sailing in the GitHub sea, I found some amazing lands to dock on. The extra one is mine. And I’d like to invite you to embark on my project.

App Ideas

Have you ever wanted to build something, but you had no idea what to do? Just as authors sometimes have “writers block” it’s also true for developers. This list is intended to solve this issue once and for all! Go➡

These applications are:

great for improving your coding skills muscle;
great for experimenting with new technologies new;
great for adding to your portfolio to impress your next employer/client;
great for using as examples in tutorials (articles or videos);
easy to complete and also easily extendable with new features;
This is not just a simple list of projects, but a collection that describes each project in enough detail so that you can develop it from the ground up!

Each project has the following features:

A clear and descriptive objective;
A list of User Stories which should be implemented (these stories act more as a guideline than a forced list of To-Do’s. Feel free to add your own stories if you want);
A list of bonus features that not only improve the base project, but also your skills at the same time.

All the resources and links to help you find what you need to complete the project

The Book of Secret Knowledge

This repository is a collection of various materials and tools that I use every day in my work. It contains a lot of useful information gathered in one piece. It is an invaluable source of knowledge for me that I often look back on. Go➡

Awesome Cheatsheets

Awesome cheatsheets for popular programming languages, frameworks and development tools. They include everything you should know in one single file. Go➡

Tech Interview Handbook

No one has time to do a few hundred LeetCode questions. Here’s free and curated technical interview preparation materials for busy engineers, brought to you by the author of the Blind 75 List. Go➡

Besides the usual algorithm questions, other awesome stuff includes:

How to prepare for coding interviews
Interview Cheatsheet — Straight-to-the-point Do’s and Don’ts
Algorithm tips and the best practice questions categorized by topic
Interview formats of the top tech companies
Behavioral questions asked by the top tech companies
Good questions to ask your interviewers at the end of the interviews
Helpful resume tips to get your resume noticed and the Do’s and Don’ts
Front-End Interview preparation
Help from you in contributing content would be very much appreciated!

Why do I want this?

This repository has practical content that covers all phases of a technical interview, from applying for a job to passing the interviews to offer negotiation. Technically competent candidates might still find the non-technical content helpful as well.

Who is this for?

Anybody who wants to land a job at a tech company but is new to technical interviews, seasoned engineers who have not been on the other side of the interviewing table in a while and want to get back into the game, or anyone who wants to be better at technical interviewing.

E-Book Foundation — Free programming books

This repo contains books, courses, interactive programming, podcasts and more, everything free and also translated to many languages. Go➡

[Extra] Make Our Lives Easier Again

In this repo, I intend to gather a lot of useful stuff such as books, guides, developer tools and much more. It’s still very primitive yet, but there are some interesting things. Go➡

12 VS Code Shortcuts To Code Faster!

Daniela Lima — Sat, 16 Oct 2021 21:50:38 +0000

Some of these tips I took from VS Code documentation. I recommend you to take a look. 📃VS Code docs.

1. Quick file open: `Ctrl + P`

2. Show terminal: `Ctrl + backtick`

3. Zen mode: `Ctrl + K, then Z`

4. Open new editor: `Ctrl + \`

5. Switch between editors: `Ctrl + 1, Ctrl + 2...`

6. Multi cursor selection: `Alt + Click` or `Ctrl + Alt + Up/Down`

7. You can also add additional cursors to all occurrences of the current selection: `Ctrl + Shift + L`

8. Or if you want to select only the next occurrence: `Ctrl + D`

9. Copy line up / down: `Shift + Alt + Up/Down`

10. Move line up and down: `Alt + Up/Down`

11. Code formatting: `Shift + Alt + F` (whole document)

12. Rename: `F2`

😎 You might also like:
Python Typing

📫 Where to find me:
All my links

Como usar o Google americano (pesquisa em inglês)

Daniela Lima — Fri, 08 Oct 2021 20:38:52 +0000

Altere sua busca para qualquer região.

Quando fazemos uma pesquisa em outro idioma, a maioria dos resultados que recebemos são em português e relacionados com o nosso país. Entretanto, nós queremos, por exemplo, resultados em inglês e relacionados com os EUA. Como fazer isso?

Para fazer pesquisas em outros idiomas e/ou acessar o Google de determinado país, basta alterar a sua região nas configurações do próprio Google. Isso pode ser feito em qualquer navegador de internet.

Siga os passos abaixo:

No canto inferior direito, clique em 'Configurações' e, em seguida, em 'Configurações de Pesquisa'.
Em 'Resultados da pesquisa', role para baixo da página, encontre 'Configurações de região', selecione o país desejado e salve.

Considere seguir este perfil para mais postagens como essa!

Outros conteúdos:

Python Typing

Python Typing

Daniela Lima — Thu, 30 Sep 2021 23:51:53 +0000

Annotations & Type Hints for Python 3.5 or above.

DISCLAIMER: It’s a “detailed summary”. Everything here came from Tech With Tim video about Python Typing. I’m making this post for my learning, also to store in a place I can keep checking every time I need. All credit should go to Tim and his excellent explanation.

Tim's video.

Why do that?

It’s just to better documenting your code, to make it easier for autocomplete, and for other developers to understand what to pass. Therefore, it doesn’t change the functionality of your code. If you pass an int instead of the expected str, it won’t crash.

Static Code Analysis Tool (MYPY)

Tool to verify type mismatch — catch errors before running your code.

$ pip install mypy

Usage:
$ mypy /../Path/your_file.py

In Python, you might already know, we don’t have to define the types of our variables, functions, parameters, etc. We can just write it. However, in a lot of other programming languages that are static and strongly typed, you need to declare the type of the variable before you can assign a value to it. And then that variable can only hold that type throughout the entire program execution.

For example, in other languages, if you declare an int and give it a str, int x = “hello” , it’s going to crash.

But in Python, since it’s dynamically typed, we can just do x = 1.

Variable hint/annotation:

For x: str = 1, this is not enforcing that x store a string, it means that x should store one. Therefore, it won’t crash, because it’s simply documentation — doesn’t change the code behavior.

For x: str = 1 it returns:

error: Incompatible types in assignment (expression has type "int", variable has type "str")
Found 1 error in 1 file (checked 1 source file)

Parameter annotation:

def something(numb: float) -> int:
    return 2021 + numb

OR if you don't return anything, just use None

def person(name: str, age: int, height: float) -> None:
    print(f'{name} is {age} yo and {height} feet tall.')

The numb: float means it should receive a float and -> int should return an int.

Some advanced types:

List Type:

So a lot of times you have some, well, more advanced or more complicated types that you want to pass as an argument to a function. For example, maybe we want to have a list that has other three list in it. And these lists all have int inside them. Well, what is the type for that?

[[1, 2], [3, 4], [5, 6]]
x: list[list[int] = []

No no no... This doesn't work!

>>> TypeError: 'type' object is not subscriptable

For that, we need to import the List type from the typing module.

from typing import List

x: List[List[int] = [[1, 2], 3, 4]]    with capital L

$ mypy ../this_file.py
>>> Success: no issues found in 1 source file.

And now it's a valid type.

Dictionary Type:

Same for dictionaries, but now we just need to specify the key and the value.

from typing import Dict

x: Dict[str: str] = {"State": "Capital"}    with capital C

Set Type:

from typing import Set

x: Set[str] = {"a", "b", "c"}    with capital C

Custom Type:

This is my vector type. So now that I’ve done this, I can use vector and wherever I use vector list float will kind of be replaced there.

from typing import List, Dict, Set

Vector = List[float]

def foo(v: Vector) -> Vector:
    print(v)

Autocomplete would be: foo(v: List[float]) -> List[float]

Where there’s Vector, List[float] will replace it.

You can store a type inside a variable and use a variable as a type.

Vectors = List[Vector]    (List[List[float]])

def foo(v: Vectors) -> Vector:
    pass

Autocomplete would be: foo(v: List[List[float]]) -> List[float]

Optional Type:

def foo(output: bool=False):
    pass

Everything is fine here — no errors. However, the autocomplete (foo(). Ctrl+Space) doesn’t show the type because it’s output optional. But to make this the most correct type that it can be, you need to specify that it’s optional.

from typing import Optional

def foo(output: Optional[bool]=False):
    pass

Any Type:

This is very straightforward. But if you are willing to accept anything, then just use the any type.

from typing import Any

def foo(output: Any):
    pass

Writing this is the exact same thing as just doing def foo(output)

Because if you don’t give it a type, it’s assumed it could be anything. This is just being more explicit. You’re saying this is intended to actually accept anything.

Sequence Type:

So a lot of times when you are writing a function, in Python, you want one of the parameters to be anything that’s a sequence, you don’t care what type of sequence it is. You just want it to be a sequence.

You’ll be needing this there’s no way to specify, if the parameter should be a list or a tuple. However, if you use sequence, you’re saying that both the tuple and the list count as a sequence. And you can also specify what type the sequence should store.

from typing import Sequence

def foo(seq: Sequence[str]):
    pass

foo(("a", "b", "c"))
foo(["a", "b", "c"])
foo("hello")    ("Strings are immutable sequences of Unicode")

$ mypy ../this_file.py
>>> Success: no issues found in 1 source file.

But if you give an *int* or a *set*:

foo(1)
foo({1, 2, 3})
str: "anything that can be indexed"

$ mypy ../this_file.py
>>> error: Argument 1 to "foo" has incompatible type "int"; expected "Sequence"
Found 1 error in 1 file (checked 1 source file)

Tuple Type:

It’s a little different of the list, so what you need to do is specify what is going to be stored at every single position in the tuple.

from typing import Tuple

x: Tuple[int] = (1, 2, 3)

$ mypy ../this_file.py
>>> error: Incompatible types in assignment (expression has type "Tuple[int, int, inti]", variable ha type "Tuple[int]
Found 1 error in 1 file (checked 1 source file)

x: Tuple[int, int, int] = (1, 2, 3)
y: Tuple[int, str, int] = (5, "hello", 10)

$ mypy ../this_file.py
>>> Success: no issues found in 1 source file.

Callable Type:

This is what you use when you want to accept a function as parameter. Well, the proper type for this function would be callable. And then, in square brackets, define the parameters that the callable function is going to have, as well as the return type.

from typing import Callable

                     |parameters|return|
def foo(func: Callable[[int, int], int] -> None:
    func(1, 3)

This function has to have two *int* parameters and return an int

def add(x: int, y: int) -> int:
    return x + y

def foo(func: Callable[[int, int], int]) -> None:
    func(1, 3)

foo(add)

$ mypy ../this_file.py
>>> Success: no issues found in 1 source file.

But if we remove or add one parameter, we get an error because this function doesn't have the correct parameters inside.

To return a Callable Function:

def foo() -> Callable[[int, int], int]:
    def add(x: int, y: int) -> int:
        return x + y
return add

foo()

OR with lambda

# normal
def foo() -> Callable[[int, int], int]:
    return lambda x, y: x + y

# variables specified
def foo() -> Callable[[int, int], int]:
    func: Callable[[int, int], int] = lambda x, y: x + y
    return func

foo()

They are all fine.