E já sem perder tempo, vamos dar início começando pela Introdução à Variáveis.

Como você bem sabe, a maioria, se não todos os apps, armazena informações que são usadas para mudar e atualizar conforme você usa a aplicação. Por exemplo, um simples Game armazena dados da sua pontuação, quantidade de pontos de vida e créditos que você possui conforme você vai jogando.

Dessa forma, os apps usam a memória do dispositivo para fazer esse armazenamento e as devidas alterações, seja ele um computador, smartphone ou console. Aprender como usar essa memória, é um ponto essencial para um programador.

A forma mais comum de aproveitar a memória de um computador, e aqui você entenda como qualquer dispositivo que rode um app, é através da criação de variáveis.

Variáveis

Variáveis são apenas espaços, ou containers, que servem para guardar um valor, uma vez que esse espaço é criado ele é armazenado na memória do computador e pode ser utilizado e atulizado diversas vezes no seu app.

Criar uma variável em Dart é bem simples, basta usar a plavra chave var (palavra-chave, já já falamos mais disso) seguida de um rótulo que você deseja usar, que servirá de nome e identificador dessa variável. Aqui você pode se sentir à vontade para escolher o nome dessa variável, mas é recomendado que seja dado um nome descritivo, assim ficará mais fácil a leitura do código. O proprio Dart também nos fornece algumas práticas para ajudar a nomear melhor nossas variáveis, como por exemplo:

• começar sempre com letras e em minúsculo;

• sempre usar camelCase para nomes compostos;
  exemplos:
  var minhaVariavel = 'variavel';
var minhaOutraVariavel = 2;

• evitar nomes com separadores;

  • exemplo: var minha_variavel = 2;

• não usar as palavras-chave da linguagem;

  • exemplo: var var ='variável';

Começou!

Agora voltando lá no exemplo do Game, vamos usar variáveis para armazenar o nossa pontuação, pontos de vida e os créditos no game.

Iniciando por nossa pontuação, então podemos "declarar" uma variável com o nome score e vamos "assinar/iniciar" um valor inicial 0 (Zero) que será atualizado conforme necessário. Feito isso, partimos para os ponto de vida, que aqui vou iniciar com o valor 100 (cem) representando 100% de vida. Lembrando sempre dos rótulos/nomes das variáveis pois vamos precisar deles para atualizar seus valores.

Nesse caso nomearei com as palavras em inglês, por preferir seguir um padrão, já que as palavras-chave da linguagem está semanticamente em inglês. Mas nada impede de fazer em português, caso prefira, pode seguir com os respectivos nomes pontuacao e pontosDeVida

var score = 0;
var healthPoints = 100;

Para atualizar os valores das variáveis basta reassinar a variável desejada com um novo valor, e dessa vez basta chamar a variável pelo nome e atrinuir um novo valor, sem a necessidade da keyword (palavra-chave) var.

score = 10;
healthPoints = 95;

Contextualização

Acima vimos palavras como declarar, assinar e iniciar. Isso significa o seguinte. Ao declarar uma variável, estamos criando de fato um novo espaço na memória do computador, usando a estrutura de sintaxe:
[paravra-chave] [rótulo/nome]
var minhaVariavel;

Assinar ou iniciar é atribuir um valor para essa variável armazenar memoria. A diferença seria que geralmente usamos o termo "iniciar" para atribuir o valor à variável no momento da declaração:
[palavra-chave] [rótulo/nome] [sinal de atribuição] [valor]
var minhaVariavel = 'valor string';

Já assinar é qualquer momento que atribuimos um valor à variável, seja para iniciar um valor ou para atualizar. Por exemplo:
Inicialização direta
var minhaVariavel = 'valor string';
atualização do valor (reassinar)
minhaVariavel = 'Novo valor';

Declaração sem iniciar com valor
var minhaOutraVariavel;
inicializando com um valor
minhaOutraVariavel = 'outro valor';
atualizando com um novo valor
minhaOutraVariavel = 'novo outro valor';

Outro ponto importante para se notar é o 'sinal de atribuição' repesentado pelo sinal de igualdade ( = ). Contrário ao comum, ele não faz referencia de igualdade, como: "pontosDeVida [é igual a] 100" | var pontosDeVida = 100;
No caso esse sinal faz referencia de atribuição, ou seja:
"pontosDeVida [recebe o valor] 100" | var pontosDeVida = 100;

Mão na massa

Agora vamos ver o Dart lidando com as variáveis. Nesse ponto temos duas opções: Primeiro seria realizar o setup do nosso ambiente de desenvolvimento em nossa máquina local, ou usar o DartPad, que é um playground Dart, ou seja, é um ambiente de desenvolvimento online.

Para esses primeiros contatos recomendo usar o dartpad mesmo, pois vai lhe economizar um tempo, mesmo que o dartpad tenha suas limitações, nesses primeiros exemplos não vamos usar tudo até chegar no limite dela. Não por enquanto.

Para usar o dartpad basta abrir o Browser e navegar para o endereço https://dartpad.dev e você terá a seguinte interface:

Pode apagar tudo que está escrito na secção da esquerda, onde está o código, e colar o código abaixo, logo depois pode clicar no botão "Run" e esperar a execução do código:

void main() {
    var minhaVariavel;
    minhaVariavel = 'Nova Variável';

    print(minhaVariavel);
}

Note que no lado direito, apareceu o texto que está assinado em nossa variável. Esse espaço é o debug console, e é ai que são apresentados os logs da execução do app. Como não temos nenhuma mensagem de erro, isso significa que tudo ocorreu bem!

Note ainda que há uma linha azul sublinhando o nome da variável. No canto inferior esquerdo, agora está um modal com um warning, no qual a mensagem traduzida indica que "uma variável não inicializada deve ter uma anotação de tipo".

Se agora invés de assinar o valor da variável na linha seguinte, e já iniciar o valor durante a declaração podemos notar que o warning desaparece:

Isso é um dos pontos fortes do Dart, como ele fornece um compilador que tanto analisa o código, durante o tempo de execução do app, ele também faz a análise antes do tempo de execução (compilações JIT Just in Time, e AOT Ahead of Time) e faz com que os programadores consiga ver possíveis erros e otimisações de código enquanto está desenvolvendo, invés de precisar compilar e executar o app para poder detectar esses pontos.

Próximos passos

Antes de continuarmos para os próximos conseitos dos Fundamentos de programação, vou deixar algums challenges como prática do que foi visto nesse tópico.

No código existente, tente criar novas variáveis, como score, life e gold. Crie e inicialise com seus devidos valores.

Bônus: Tente fazer com que o programa mostre os valores das variáveis no debug console.

No Próximo tópico vamos explorar os tipos de variáveis e a estrutura de nosso app. Entender o papel do main(), print() etc

Volkov recentemente recorreu ao Twitter e outras mídia sociais para destacar o poder do Vision Pro no mundo dos jogos. Em sua demonstração, ele se imergiu perfeitamente no mundo do mais recente sucesso dos Games Palworld, utilizando os recursos avançados do dispositivo de $3,500, Steam Link e um controle Bluetooth.

A integração de elementos de AR e MR na experiência de jogo criou uma sinergia que ultrapassou as configurações convencionais de jogos. À medida que Volkov navegava pelas paisagens virtuais de Palworld, ficou evidente que a incursão da Apple na tecnologia de consumo não se limitava apenas a aprimorar a realidade, mas a remodelar a maneira como percebemos e interagimos com o entretenimento digital.

Em um vídeo subsequente, Volkov aproveitou a oportunidade para fazer uma comparação marcante entre o headset da maçã e um moderno projetor de jogos de 115 polegadas instalado em seu escritório. Os resultados foram surpreendentes, pois ele enfatizou a superioridade do headset sobre o projetor, tornando este último quase diminuto em comparação.

O que diferencia o Vision Pro no cenário dos jogos é a perfeita integração de tecnologia de última geração. A fusão de recursos de AR e MR não apenas aprimora as experiências visuais, mas também abre novas possibilidades para jogabilidade imersiva. A compatibilidade do dispositivo com Steam Link e controles Bluetooth destaca ainda mais o compromisso da Apple em fornecer uma plataforma de jogos versátil e fácil de usar.

O sucesso do Vision Pro no setor de jogos poderia potencialmente marcar uma mudança de paradigma na indústria, introduzindo uma nova era em que as tecnologias de AR e MR se fundem com os jogos tradicionais. À medida que entusiastas de jogos e aficionados por tecnologia exploram o potencial não explorado da mais recente oferta da Apple, o Vision Pro pode se destacar como um divisor de águas, redefinindo os limites do entretenimento interativo.

Enquanto alguns podem ter inicialmente subestimado o Vision Pro como sendo principalmente um dispositivo de AR/MR, a demonstração de Volkov serve como um testemunho convincente de sua versatilidade. A jogada estratégica da Apple ao posicionar o headset como uma maravilha tecnológica abrangente parece estar rendendo frutos, atendendo com sucesso a um público mais amplo, incluindo jogadores ávidos em busca de uma experiência revolucionária de jogo.

À medida que o Vision Pro continua a ganhar destaque em diversas comunidades de tecnologia, ele provoca discussões intrigantes sobre o futuro dos jogos e o papel que a realidade aumentada desempenhará na moldagem desse futuro. A incursão ousada da Apple no mundo dos jogos com o Vision Pro anuncia uma era em que a inovação não conhece limites, e as fronteiras entre a realidade e a virtualidade se tornam tênues na busca por experiências de jogo inigualáveis.

Referências:
Alex Volkov (Thursd/AI) - Twitter
Mark Tyson - Tom's Hardware

First things

First things first. This article (to make this one light) it covers macOS and Linux Users, so for Windows Users I will write another one covering setup, customization and improvements.

What Will I get?

I choose some plugins that help me at work like: In line auto-complete command, common suggestions, Git Icons indicators and Project path indicators, Colorful semantics and so on.

The Tools

To get these features on your terminal you don't need another Terminal app itself. You can get one without problem, like iTerm for macOS or DeepinConsole or something else, but it isn't a requirement.
All you'll need is:
- zsh: a shell (like bash) built-in on macOS Catalina and Later;
- ohmyzsh: to be able attach plugins, like zinit;
- zinit installer and its plugins to do things;
- themimg: theme and fonts for custom icons for Languages/frameworks etc;

Let's Start

So, if you are on macOS Catalina or Later you have the zsh shell built in on your terminal. In another hand you must to install it and make it your default shell.

on Linux
brew install zsh or
sudo apt install zsh

Make it default:
chsh -s $(which zsh)

on macOS
brew install zsh

make it default: on newest macOS versions.
chsh -s /usr/local/bin/zsh

on HighSierra and older:
chsh -s /bin/zsh

Doing this you should be able to run zsh on your machine. To check if works fine run zsh --version or /bin/zsh --version

Now we will install OhMyZsh you can install it using three methods, curl, wget and fetch:

curl (recommended):

sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

wget:

sh -c "$(wget -O- https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

fetch:

sh -c "$(fetch -o - https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

Now let's download the theming and fonts/icons. To the theme you can choose anyone you like, I got Dracula cos' I do like it.
So check Dracula's website and pick a theme for your terminal. There are some terminals on Compactibility List: Gnome, iTerm, Terminal.app(that is my current on this example) etc. Next, follow the steps to download it and activate:

https://draculatheme.com/

The fonts and icons we'll use FiraCode and Spaceship Theme. With FiraCode we can use a free monospaced font with programming ligatures. SpaceShip make some icons from git, languages version, Docker and path be displayed on terminal. So just follow the Github Release link, download and install the font format you prefer.
Then select FiraCode on your terminal profile, as the image bellow:
Terminal > Preferences > Profile > Font

For Spaceship you just need a couple of command to download, link and set it on zsh profile file.

Download Spaceship:

git clone https://github.com/denysdovhan/spaceship-prompt.git "$ZSH_CUSTOM/themes/spaceship-prompt"

Then link it:

ln -s "$ZSH_CUSTOM/themes/spaceship-prompt/spaceship.zsh-theme" "$ZSH_CUSTOM/themes/spaceship.zsh-theme"

So now inside the file ~/.zshrc replace the default theme on ZSH_THEME variable like this: ZSH_THEME=”spaceship” then restart the terminal.

Now we will set the spaceship settings. At the botton of ~/.zshrc paste the following code:

SPACESHIP_PROMPT_ORDER=(
user # Username section
dir # Current directory section
host # Hostname section
git # Git section (git_branch + git_status)
hg # Mercurial section (hg_branch + hg_status)
exec_time # Execution time
jobs # Background jobs indicator
exit_code # Exit code section
char # Prompt character
)

SPACESHIP_USER_SHOW=always
SPACESHIP_PROMPT_ADD_NEWLINE=false
SPACESHIP_CHAR_SYMBOL="$_❯"
SPACESHIP_CHAR_SUFFIX=" "

these fields SPACESHIP_CHAR_SYMBOL and SPACESHIP_CHAR_SUFFIX You can use any String you want to customize the first and second line on input terminal. So Mine looks like that:

Final touch

Finally let’s adds the plugins and finish the boost. First install zinit installer:

bash -c "$(curl --fail --show-error --silent --location https://raw.githubusercontent.com/zdharma-continuum/zinit/HEAD/scripts/install.sh)"

When it ends restart the terminal and if some installation is needed it will run by itself, so wait the end of instalation and go to next step.
Now open again the ~/.zshrc file and adds the following code bellow the last line on the file:

zinit light zdharma-continuum/fast-syntax-highlighting
zinit light zsh-users/zsh-autosuggestions
zinit light zsh-users/zsh-completions

The file will looks like that:

Conclusion

So! Now you have a terminal with thousands of add-ons for common tools like Yarn, Homebrew, Node etc (you just need to press TAB to complete commands); commands based on run history; syntax highlighting with missing command indicator and so on!

I hope you enjoy it and these tips save some seconds by day and hours by weeks or by year on your job (😁😅🤣).
seeya!

As announced in 2016, FuchsiaOS isn't an Android's successor, leastways it’s not its intention. In the officials documentation, the Fuchsia team describes that it will not focus on an “User Experience”, but rather on multiple experiences.

This implies that more than Android can be, Fuchsia will be more responsive and multi-platform, “targeting” on several platforms such as: Smartphones, TVs, HomeCasts, Speeches, Desktops, Watches, and maybe any others.

Since the last article I wrote about the system two years ago, a lot of things have changed, but we’ll see all of that in this article and some other news.

Modular

FuchsiaOS, by now just Fuchsia, was designed to be an entirely modular system, allowing its libraries and applications to be entirely removed, updated and added on it without the system get affected .

This, in addition to ensuring system integrity, allows it to be more secure, for example, security patch updates can be easily obtained with a simple package without compromising user data or others applications.

Technologies / Stack (?)

The technologies used in the development of Fuchsia are, of course C and C++, Rust, GO, and Dart. Thus, developing for Fuchsia the developer will be able to choose the language used in the backend — as being a fully modular system Fuchsia has no problem with that.

Its native frontend applications are developed in Dart/Flutter, which will greatly facilitate the migration from the Android platform to Fuchsia, and still in market adoption, since Flutter is one of the most successful technologies of the last years!

An interesting point to check is that today it is totally viable to develop apps using Dart/Flutter and low-level languages — languages ​​that communicate directly with the operating system, such as C/C++ and Rust — through the use of the Dart:ffi library , and that I’ve been written an article about the integration of Rust with Flutter and I recommend reading it.

Architecture

Arquitetura do Fuchsia

Fuchsia was designed to be a secure, highly upgradable, modular, and performant system. We discussed this in the last article, but this time we have news, the system now has more architectural principles to guide its development and design.

The system is no longer an “Experiment”, as it was previously treated, but a production-level system. Like the new Google Nest Hub that already comes with a version of Fuchsia running natively.

Secure

It means that all software running on Fuchsia, including applications and components of the system itself, follow the principle of least privilege (principle of least privilege), which in short, requires that in an abstraction layer of the operating system environment, each module — such as a process, a user, or an application — is able to access only the information and resources necessary for its execution.

Updateble

Upgradable implies that Fuchsia packages are designed to be updated independently or even Instant Delivery, or Enphemery, which means that packages are designed to be decoupled, and so come and go from the device as needed, and the system is always kept up to date.

Modular/Inclusive

Modular means that the system is language independent. Since it is designed to be extensible and allow for the integration of software written in multiple languages ​​and runtimes, you can either develop using C, C++, Rust, Go, Python, or Dart/Flutter.

Kernel

The system core is Zircon, which is the kernel with a set of libraries which manage the startup and bootstrapping of the system. All system components outside the kernel are implemented, in what we call userspaces, and totally isolated from the critical layers of the system — reinforcing the principle of least privilege, as we already talked about here — , so even Device Drivers are isolated in userspaces.

Zircon brings the architecture and many of the concepts we know through Microkernels. This architecture makes it possible for Fuchsia to minimize the amount of trust code as much as possible, limiting Memory management, Scheduling, and IPC (Inter-process communication).

Comparação entre um kernel convencional e o Zircon Kernel

So we have a possible problem: if the entire core of the system is isolated from the userspaces, how can we develop apps that need information or even “talk” with the system?

So to our code perform interactions such as: Manual memory management, system tasks or processes, IPC, device I/O etc; we can use system calls. These processes that execute the system calls are executed by the vDSO (virtual Dynamic Shared Object — libzircon.so) library which reads a generated kernel image, instead of directly reading the files in the kernel. While reading this image, the userspace code is given only the necessary privileges, — how these privileges are managed we can discuss in another article.

But why do I need to know this?

The short answer is: you don’t.

But at all, if you are a developer, the vast majority of apps that you might need to develop for Fuchsia, you will probably use Events, Streams, Channel, Socket, etc. And it’s all part of Inter-Process Communication (IPC), so if that’s your case, here’s where you should start study to develop for Fuchsia 😉.

(Fuchsia dev Road map soon)

Why Fuchsia is so interesting

Remember that Fuchsia is not a Linux-based system. Absolutely unlike Android that runs on top of Linux Kernel, Fuchsia is completely independent, the entire system and kernel is developed by Google, and fully opensource (afaik), you can submit Pull Requests for the system or even work parallel to it, creating a new system for your pleasure or need. A good example of this is dahliaOS which is a Zircon/Linux (releases are on Linux based) developed based on Fuchsia for the desktop, (I gave a two cents on it 😅) I recommend seeing the Dio Linux video (if you speak Portuguese) that talks a little about the system, it’s worth checking it out!

What I like the most interesting thing about the system is that its ecosystem is free. What I mean is, while the complete system is developed by Google, their main frontend development language, Dart, is too! This allows for greater support to developers and freedom of growth for both (System and Language). But also, it gives the freedom to develop with any language that the developer finds suitable.

Fuchsia to fix, it’s not to kill

Fuchsia is not the “Android killer” system. Many limitations that Android had, with Java or JVM, the linux kernel etc, we won’t have with Fuchsia. Another point is that Android’s niche is mobile devices, which initially is not Fuchsia’s focus, and actually there isn’t, until then, a focus, but “focals”: multiple screens, embedded devices, IOT, SmartHome etc.

Testing Fuchsia

At the time of writing this article we already have simpler ways to run the system on our machine without having so much work, such as the Fimage.

Fuchsia — Fimage Home Dashboard

Fuchsia — Fimage navigator

Fimage is a lightweight KVM based emulator, AEMU (Android Emulator), Android emulator that comes with Android Studio, and FEMU (Fuchsia Emulator). Developed by the dahliaOS team to allow anyone to run and test Fuchsia on their machine, without the need to download over 200 Gigas of Source Code and spend hours building the system. So if you would like to test the system neat and not go to so much trouble, this is the best option so far. Instructions, documentation and download here. If you want to have all the build experience and get your hands dirty, just follow the guide on the website fuchsia.dev.

On the other hand, if you want to experience a complete operating system with a more refined UI with a shell and Desktop Environment completely built in Flutter and with a hint of Fuchsia, you can choose to try dahliaOS. The system has both a version with the linux kernel, which allows it to be installed on almost any hardware, and a version with Zircon with very strict compatibility (by now only on FIMAGE).

dahliaOS Arquitetura

All download options, instructions and where to find support are in the dahliaOS Github. Bearing in mind that the system is under development and the team works in its free time on system development, therefore it is not recommended to use the system as a daily driver.

dahliaOS desktop

dahliaOS — Apps menu

Conclusion

If you are a developer and are interested in starting testing development on Fuchsia, there are still some issues. The standard Flutter SDK doesn’t support debugging for the Fuchsia host yet, so it’s necessary to use an SDK available in the Fuchsia Repository. As Fimage you can even debug, but it needs some adjustments, but there is no support by Fimage. Remembering that I’m already producing a guide for Fuchsia devs, like a system tears down, so just keep an eye out here 😉.

Fuchsia has been my bet since I met it in mid 2018. I believe it is a revolutionary system, not because it brings new things, as there are several Opensource systems that have similar characteristics and concepts for some time, but because it brings these concepts and for being in the hands of Google. For those who don’t remember Dart, it started as an experiment, got a web proposal and finally Flutter, and as Flutter grew, the language grew to accompany the development of the Framework.

But I’m not saying that Flutter will drag the development of Fuchsia, but that by having the entire stack of the system in hand, the possibilities are limited by Google itself. Think with me, the system targets multiple user experiences (several platforms), and Flutter is designed for Multiplatform, so we have both layers supported from the same house. (Not counting Google hardware: Nest Hubs, Google TVs, Google Home etc). Of course, everything has its good and bad side, and yes, having everything under your hands can bring several problems, which we can discuss further on the subject.

Well, I hope it was a good read, and I’m available to discuss the subject, opinions, suggestions, anyway. If you’re interested, feel free to follow us on Github and social media, both me and the Fuchsia and dahliaOS team, we have Discord and channels to exchange an idea. Thanks 😁!.

GitHub; Instagram, Twitter, XDA: @allansrc

First things First

Primeiramente o mais importante. Nesse post irei mostrar como configurar o básico do terminal e como deixar ele pronto para otimizar no dia-a-dia de dev. Mas se você quiser também dá aquele boost em sua máquina (ou instancia) Linux ou MacOS, aqui neste outro artigo mostro como fazer nessas plataformas :)

O que terei no final desse “Guia”?

Eu escolhi alguns módulos que ajudam no trabalho, por exemplo:
- Preenchimento automático de comando em linha;
- Sugestões comuns/mais usados;
- Indicadores de Git, Path e Projeto;
- E destaque coloridos para ajuda na semântica do comando (Temas!).

Ferramentas

Para podermos ter esses módulos auxiliares, vamos precisar de está usando o OhMyPosh no app Windows terminal, que pode ser baixado na Microsoft Store, pelo gerenciador de pacote da microsoft winget, ou scoop(que é o ‘homebrew’ para Windows) e até diretamente pelo powershel (manual).

Caso o Windows Terminal já não esteja instalado na sua máquina, instale usando uma das opções que preferir, mas recomentdo usar o app da loja Microsoft: link. Em sequida instale o OhMyPosh usando uma das opções abaixo. Copie e cole o comando no seu terminal (Windows Terminal / PowerShell):
- winget::

winget install JanDeDobbeleer.OhMyPosh -s winget

- scoop:

scoop install https://github.com/JanDeDobbeleer/oh-my=posh/releases/lastest/download/oh-my-posh.json

- manual:

Set-ExecutionPolicy Bypass -Scope Process -Force; Invoke-Expression ((New-Object System.Net.WebClient).DownloadString('https://ohmyposh.dev/install.ps1'))

Feito isso, reinicie o terminal, e terá instalado o ohmyposh e o seu pacote de temas. Caso deseje ver o caminho que foi feito a instalação, execute o seguinte comando:

(Get-Command oh-my-posh).Source

Temas e Fontes

O próximo passo agora, é fazer a instalação da Fonte. Assim poderemos ter os ícons de branching do Git, font-ligatures etc. Para esse Setup eu escolhi a Fonte FiraCode que venho usando há bastante tempo e nunca tive problemas, uso inclusive como fonte pricipal do VSCode.

Para instalar a fonte basta rodar o seguinte comando no terminal e selecionar a fonte desejada com as setas (⬆️/⬇️). Para esse exemplo recomendo descer até achar a fonte FiraCode Nerd Font:

oh-my-posh font install

Após a instalação, vá nas configurações do terminal. Por padrão o atalho ctrl+, abre as configurações, mas caso não funcione, basta clicar no ícone de contexto do terminal e navegar para as configurações e em seguida selecione a opção “Abrir o arquivo JSON” (Imagens abaixo):

Feito isso, no arquivo aberto, localize a key profile/defaults e deixe a key font com o valor como no exemlo abaixo. Caso não exista a key fonte, adicione-a.

{
    "profiles":
    {
        "defaults":
        {
            "font": 
            {
                "face": "FiraCode Nerd Font"
            }
        }
    }
}

Para adicionar suporte às fontes no terminal integrado do VSCode, você só precisa abrir o vscode, precisone F1 para abrir a command pallet e digitar “settings json” e selecionar a opção para abrir as configurações do vscode “Open User Settings (JSON)”. Localize e altere o campo terminal.integrated.fontFamily como na imagem abaixo, salve e reinicie o vscode, e tudo certo!

Agora partimos para os temas. Edite seu script de profile do PowerShell. Você pode encontrar-lo na variável $PROFILE do PowerShell. Por exemplo, usando o VSCode:
code $PROFILE
Caso o comando gere algum erro, ou o arquivo ainda não existir crie o arquivo e tente novamente.
Para criar o arquivo execute o seguinte comando:

New-Item -Path $PROFILE -Type File -Force

Ao conseguir abrir o arquivo, adicione o sequinte código e salve:

oh-my-posh init pwsh | Invoke-Expression

Depois de adicionado, recarregue seu PROFILE para que as alterações tenham efeito, ou reinicie o terminal. Agora você notará que o terminal já está diferente.

terminal with ohmyposh prompt

Toques finais

Agora já temos o teminal com quase tudo pronto. Caso queira explorar a diversidade de temas basta rodar o comando Get-PoshThemes que será listado os temas e o comando para o selecionar como default.

Por exemplo, no meu caso o comando exemplo foi:

oh-my-posh init pwsh --config 'C:\Users\allan\AppData\Local\Programs\oh-my-posh\themes\jandedobbeleer.omp.json' | Invoke-Expression

Caso eu queira mudar o tema para o “zash” basta eu substituir o path do arquivo final, por exemplo: de ..\themes\jandedobbeler.omp.json por .\themes\zash.omp.json

Para concluir, vamos abrir o arquivo $PROFILE novamente e colar o código abaixo, após isso, salve e reinicie o terminal:

Set-PSReadLineOption -PredictionSource History
Set-PSReadLineOption -HistorySearchCursorMovesToEnd
Set-PSReadLineKeyHandler -Key UpArrow -Function HistorySearchBackward
Set-PSReadLineKeyHandler -Key DownArrow -Function HistorySearchForward

Isso adicionará o Predictive IntelliSense que é implementado no mecanismo do PowerShell e apresentado por meio do módulo PSReadLine e fornece previsão baseada em histórico no InlineView.

Caso você esteja vendo algum erro no seu terminal ao abrir ou ao tentar execultar alguns dos comando desse guia parecido com o retorno abaixo, você precisará atualizar seu módulo PSReadline:

Get-PSReadLineKeyHandler : A parameter cannot be found that matches parameter name ‘Key’

Para atualizar basta seguir os passos de instalação/update da documentação oficial do PSReadLine disponível aqui.

E Voilà! O terminal está pronto para uso e otimizado com complementos para ferramentas comuns como git, Node, comandos baseados no histórico de execução, realce de sintaxe com indicador de comando ausente e assim por diante!!

Espero que você goste e que essas dicas economizem alguns segundos por dia e horas por semana ou por ano em seu trabalho.
Até mais, e Até!

#2Articles1Week

Anunciado em 2016, o FuchsiaOS não se trata de um sucessor do Android, pelo menos não é o seu intuito. Na própria documentação oficial, a equipe do fuchsiaOS descreve que este não terá seu foco em uma “Experiência de Usuário”, mas sim em múltiplas experiências.

Isso implica que mais que o android já pode ser, o fuchsiaOS será mais responsivo e multiplataforma, “mirando” em diversas plataformas como: Smartphones, TVs, HomeCasts, Speeches, Desktops, Watches entre outros.

Desde o último artigo que escrevi sobre o sistema, há dois anos, muitas coisas mudaram, mas vamos ver tudo isso nesse artigo e mais algumas outras novidades.

Sistema Modular

O FuchsiaOS, agora somente Fuchsia, foi projetado para ser um sistema inteiramente modular, permitindo que suas bibliotecas e aplicações possam ser inteiramente removidas, atualizadas e adicionadas sem que o sistema sofra com isso.

Isso além de garantir integridade do sistema, permite ainda que este seja mais seguro, por exemplo, atualização de patches de segurança podem ser facilmente obtidos com um simples pacote em uma “FuchsiaStore” sem comprometer dados do usuário ou outras aplicações.

Tecnologias

Das tecnologias usadas no desenvolvimento do Fuchsia estão, obviamente o C e C++, Rust, GO, e Dart. Ao desenvolver para o SO o desenvolvedor poderá escolher a linguagem usada no backend, já que por ser um sistema inteiramente modular o Fuchsia não terá nenhum problema com relação a isso.

Suas aplicações frontend nativas são desenvolvidas em Dart/Flutter, o que facilitará em muito a migração da plataforma Android para Fuchsia, e ainda sim em adoção de mercado, já que Flutter é uma das tecnologias mas bem sucedida dos últimos anos!

Um ponto interessante a se notar é que, hoje é totalmente viável desenvolver apps usando Dart/Flutter e linguagens low-level — linguagens que se comunicam diretamente com o sistema operacional, como C/C++ e Rust — através do uso da biblioteca Dart:ffi, e que inclusive já escrevi um artigo sobre a integração de Rust com Flutter e recomendo a leitura.

Arquitetura

Arquitetura do Fuchsia

O Fuchsia foi projetado para ser um sistema seguro, altamente atualizável, modular e performático. Isso já discutimos no ultimo artigo, mas dessa vez temos novidades, o sistema agora conta com mais princípios arquiteturais para guiar seu desenvolvimento e design.

O sistema não se trata mais de um "Experimento", como era tratado anteriormente, e sim de um sistema à nível de produção. À exemplo dos novos Google Nest Hub que já vem com uma versão do Fuchsia rodando nativamente.

Seguro

Isso significa que todo software executado no Fuchsia incluindo aplicativos e componentes do próprio sistema, seguem o princípio de menor privilégio (principle of least privilege) ou privilégio mínimo, que de forma resumida, exige que em uma determinada camada de abstração de ambiente do sistema operacional, cada módulo — como um processo, um usuário, ou um aplicativo — seja capaz de acessar apenas as informações e recursos necessários para sua execução.

Atualizável

O altamente atualizável, implica que os pacotes Fuchsia são projetados para serem atualizados de forma independente ou até mesmo Instant Delivery, ou EnPhemery, o que significa que os pacotes são projetados para serem desacoplados, e assim ir e vir do dispositivo conforme necessário, e o sistema se mantém sempre atualizado.

Modular/Inclusivo

Modular quer dizer que o sistema é independente de linguagem. Uma vez que projetado para ser extensível e permitir a integração de software escrito em várias linguagens e runtimes, você pode tanto desenvolver usando C, C++, Rust, Go, Python, quanto Dart/Flutter.

Fundamentos do Kernel

O core do sistema é o Zircon, que é o kernel mais um conjunto de bibliotecas responsáveis por gerenciar o startup e bootstrapping do sistema. Todos os componentes do sistema fora do kernel são implementados, no que chamamos de userspaces e totalmente isolados das camadas críticas do sistema, reforçando o princípio de least privilege, como já falamos aqui. Assim até mesmo Drivers de dispositivos são isolados nas 'áreas do usuário'.

O Zircon trás a arquitetura e muitos dos conceitos que conhecemos através dos Microkernels, o que não faz com que o kernel seja sem funcionalidades completas e compatibilidade de hardware baixa. Muito pelo contrário, essa arquitetura de micro kernel possibilita ao Fuchsia minimize ao máximo a quantidade de código confiável, limitando à Memory management, Scheduling*, e **IPC** (Inter-process communication).*

Comparação entre um kernel convencional e o Zircon Kernel

Então temos um possível problema: se todo o core do sistema é isolado das áreas de usuário (userspaces), como podemos desenvolver apps que precisam de informações ou até "conversar" com o sistema?

Para que nosso código possa realizar interações como: Gerenciamento manual de memória, tasks ou processos do sistema, IPC, device I/O etc; podemos usar chamadas do sistema (System calls). Esses processos que executam as chamadas do sistema, são executados pela biblioteca vDSO (virtual Dynamic Shared Object — libzircon.so) que fazem a leitura de uma imagem gerada do kernel, invés de fazer a leitura direta dos arquivos no kernel. Durante a leitura dessa imagem, o código de userspace recebe apenas os privilégios necessários, — o como é gerenciado esses privilégios podemos discutir em um outro artigo.

Mas por que eu preciso saber disso?

A resposta mais curta é: você não precisa.

Mas vale lembrar que, se você é desenvolvedor, uma grande maioria de apps que você possa precisar desenvolver para o Fuchsia, provavelmente você irá usar Events, Streams, Channel, Socket etc. E tudo isso faz parte da Inter-Process Communication (IPC), então se esse é seu caso, aqui está onde você deve começar os estudos para desenvolver para Fuchsia 😉.

(Guia Fuchsia para devs em breve)

O porquê do Fuchsia ser tão interessante

Vale lembrar que o Fuchsia não se trata de um sistema baseado em Linux. Absolutamente ao contrário do Android que roda em cima da Kernel linux, o Fuchsia é totalmente independente, todo o sistema e kernel é desenvolvido pela Google, e totalmente opensource, você mesmo pode submeter Pull Requests para o sistema ou até trabalhar paralelo a ele, criando um novo sistema à seu bem prazer ou necessidade. Um bom exemplo disso é o dahliaOS que é uma distribuição Zircon/Linux desenvolvida baseada no Fuchsia para desktop, a qual inclusive faço parte do time! Recomendo ver o vídeo do Dio Linux que fala um pouco do sistema, vale a pena conferir!

E o que mais acho interessante no sistema é que o seu ecossistema é livre. O que quero dizer é, que ao mesmo tempo em que o sistema completo é desenvolvido pela Google, sua principal linguagem de desenvolvimento frontend, Dart, também é! Assim possibilita um maior suporte aos desenvolvedores e liberdade de crescimento de ambos (Sistema e linguagem). Mas também, dá a liberdade de desenvolver com qualquer linguagem que se ache adequado por parte do desenvolvedor.

Fuchsia to fix, it's not to kill

O Fuchsia não é o sistema "matador de Android". Muitas limitações que o Android teve, com o Java ou JVM, o kernel linux etc, não vamos ter com o Fuchsia. Outro ponto é que o nicho do Android é de dispositivos móveis, o qual inicialmente não é o foco do Fuchsia, e na verdade não há, até então, um foco, mais sim "focos": múltiplas telas, dispositivos embarcados, IOT, SmartHome etc.

Testando o Fuchsia

No momento em que escrevo esse artigo já temos meios mais simples de rodar o sistema em nossa máquina sem ter tanto trabalho, como por exemplo o Fimage.

O Fimage é um emulador leve baseado no KVM, AEMU (Android Emulator), emulador Android que acompanha o Android Studio, e o FEMU (Fuchsia Emulator). Desenvolvido pelo time do dahliaOS para possibilitar que qualquer um possa rodar e testar o Fuchsia em sua máquina, sem a necessidade de baixar mais de 200 Gigas de Código fonte e gastar horas buildando o sistema. Então se você gostaria de testar o sistema puro e sem ter tanto trabalho para isso, essa é a melhor opção até o momento. Instruções, documentação e download aqui. Caso queira ter toda experiencia de build e por as mãos na massa, é só seguir o guia no site fuchsia.dev.

Por outro lado, se você quer ter a experiencia de um sistema operacional completo com UI mais refinada com shell e Desktop Environment completamente construída em Flutter e com uma pitada de Fuchsia, você pode optar por testar o dahliaOS. O sistema tem tanto uma versão com o kernel linux, que possibilita ser instalado em praticamente qualquer hardware, tanto uma versão com o Zircon com compatibilidade bem restrita.

Todas opções de download, instruções e onde encontrar suporte está no GitHub do dahliaOS. Lembrando que o sistema está em desenvolvimento e o time trabalha em seu tempo livre no desenvolvimento do sistema, logo não é recomendado o uso do sistema como daily driver.

Considerações

Se você é desenvolvedor e está interessado a começar a testar desenvolvimento no Fuchsia, ainda há alguns problemas. O SDK padrão do Flutter não suporta debug para o host do Fuchsia ainda, daí é necessário usar um SDK disponibilizado no Repositório Fuchsia. Como o Fimage até dá para debugar, mas necessita de alguns ajustes, mas não há suporte por parte do Fimage. Lembrando que já estou produzindo um guia para devs Fuchsia, como um tears down do sistema, então é só ficar de olho por aqui 😉.

O Fuchsia já minha aposta desde que o conheci em meados de 2018. Acredito ser um sistema revolucionário, não por trazer coisas novas, pois há varios sistemas Opensource que trazem características e conceitos semelhantes e há algum tempo, mas por trazer esses conceitos e por estar nas mãos da Google. Para quem não lembra o Dart começou como um experimento, ganhou uma proposta web e enfim o Flutter, e conforme o Flutter crescia, a linguagem crescia para acompanhar o desenvolvimento do Framework.

Mas não estou dizendo que o Flutter irá arrastar o desenvolvimento do Fuchsia, mas que por ter toda stack do sistema em mãos, as possibilidades são delimitadas pela própria Google. Pensa comigo, o sistema mira em multiplas experiencias de usuário (diversas plataformas), e o Flutter é desenhado para Multiplataforma, logo temos as duas camadas com suporte da mesma casa. (isso sem contar com os hardwares Google: Nest Hubs, Google TVs, Google Home etc). Claro que tudo tem seu lado bom e ruim, e sim, ter tudo de baixo de suas mãos pode trazer diversos problemas, que podemos discutir mais sobre o assunto.

Bom, espero que tenha sido uma boa leitura, e estou à disposição para discutir sobre o assunto, opniões, sugestões, enfim. Se te interessou, sinta-se à vontade de nos seguir no Github e nas redes sociais, tanto eu quanto o time Fuchsia e dahliaOS, temos Discord e canais para trocar uma ideia. Valeu 😁!

Obs.: links para os repositórios, documentações, referências etc estão em destaque dispostos pelo artigo.

GitHub; Instagram, Twitter, XDA: @allansrc

Daí que vem o título para esse artigo:

Devo comprar um Mac usado ou novo¹, usar cloud², máquina virtual³ ou fazer um Hackintosh?

Nesse artigo venho trazer a minha visão como usuário de Hackintosh há pelo menos 6 anos, e de desenvolvedor multiplataforma (Flutter), além de um pre guia para o build de Hackintoshes (Plataformas AMD e Intel) voltado especialmente para o público Dev. Para detalhes de build, bem especificado, trarei uma Parte 2 para esse Artigo, então não se preocupe, e vamos nos ater na discussão principal nessa Parte 1.

First things first

Primeiramente vamos falar sobre o que usar das “ferramentas” disponíveis para builds iOS, mas se o que lhe interessa é o guia para o Hackintosh, pode avançar para o tópico específico (Tópico 4).

1. Comprar um Mac

Para começar, não há mistério, se no seu orçamento cabe comprar um Mac, seja ele um Mac Mini ou MacBook, comprar um Mac é o caminho mais fácil, plugin-n-play (ou pay-n-play).

Mas que Mac comprar, novo ou usado?

1.1 Mac usado

Se você pretende usar por alguns anos seu Mac, você deve comprar no mínimo um late 2016 — Lembrando que você deve ter o Mac OS atualizado na última versão lançada pela Apple para poder fazer seus builds, e um Mac relativamente antigo não vai suportar updates.

• A desvantagem de ter um Mac com até 4 anos é que para manter o sistema atualizado, possivelmente em algum momento será necessário recorrer à métodos não oficiais para isso.

• A vantagem é que você poderá adquirir uma máquina Apple por um preço razoavelmente inferior ao novo (óbvio) e com alguns ajustes (gambiarras) conseguirá trabalhar com ele por mais alguns anos.

1.2 Mac novo

• Das vantagens de um novo é que terá bastante tempo de suporte ao sistema, sem precisar se preocupar com procedimentos manuais e de terceiros por um bom tempo.

1.3 Mac Mini ou MacBook?

Nesse caso não há muita diferença, vai depender do seu gosto e necessidade: se precisa de mobilidade, pega um MacBook, se não, o Mac mini também é uma boa opção.

Se esse não é o seu caso, alternativas como cloud e virtualização pode ser uma solução.

2. Mac Cloud

Há várias plataformas que oferecem o serviço de build in cloud (iOS CI/CD). São exemplos de boas plataformas: CodeMagic, MacinCloud entre várias outras. Porém o uso dessas ferramentas custam alguns dólares (que vai acarretar em custo ao cliente, claro). MacinClound por exemplo tem um plano que custa 1$ por hora por um bom setup, que pode ser customizado como você preferir ou necessitar.

Codemagic apresenta um modelo de negócio um pouco diferente, no qual você pode usar seus serviços gratuitamente, com alguns limites, e é altamente recomendável para aprendizado. Os planos pagos também são muito bons e se torna uma ótima opção para você e seus clientes.

Dos pontos negativos, vale ressaltar que você estará usando uma VM remotamente, que vai impactar na fluidez e responsividade de uso do Sistema, mesmo nos melhores planos (ambos serviços) o input lag é bem alto, isso devido ao fato de se tratar de uma conexão remota etc., e pode aumentar dependendo da velocidade da sua internet.

3. Máquina Virtual Local

Uma solução um pouco “marginal” (que beira as margens dos termos de uso do Mac OS X), é usar Virtualização Local.

Você poderá optar por usar soluções como VBox ou VM Ware com imagens customizadas do Mac OS, ou outras baseadas no KVM e QEMU como SOUSUMI (bem populares em ambientes Linux), e até mesmo Docker!

Se você usa WSL a alternativa do Docker já é possível. Eu mesmo dei meus 10 cents no projeto Docker-OSX. Todo o procedimento para poder usar a solução tanto no Windows 10 quanto Windows 11 está documentado.

A desvantagem nesse ponto para todas opções dadas aqui, é que você deve ter no mínimo um hardware mid-end para poder obter um desempenho razoável: Memória suficiente para suprir a necessidade do SEU sistema e do Virtualizado, e alguns núcleos para o mesmo.

4. Hackintosh

Finalmente a solução mais “marginal”, beirando demasiadamente os termos de uso do Mac OS. Mas não se desespere, você pode checar o SLA(Software License Agreements) da Apple para seus Sistemas Operacionais e decidir se segue essa solução — ou “só vai” — , mas desde que você tenha em mãos uma licença do OS X Lion, que vai custar cerca de 60 R$, poderá usar o Mac OS X como queira.

4.1 Traçando o perfil Dev

Antes de seguirmos vamos definir qual tipo de usuário você é, para que assim esse guia seja o mais útil possível. Para isso vamos fazer algumas perguntas que dará qual caminho seguir no seu build Hackintosh.

Primeiramente, você está procurando montar um setup especialmente para Hackintosh[1], ou fazer na sua máquina atual e de preferencia sem precisar alterar/adicionar componentes[2] ?

Se sua resposta é a opção [2] basta pular para a seção 4.1.2, caso contrário vamos para as próximas perguntas na seção 4.1.1.

4.1.1 Setup build

Você já decidiu em qual plataforma irá construir seu Hackintosh (Intel / AMD)? Se sim, pule para a seção Intel na parte 2 desse artigo caso sua plataforma seja Intel, e AMD para plataforma AMD.

Escolha da plataforma:

[1]: Você precisa indispensavelmente da tecnologia HAXM?

Se sim, vai de Intel. Só pula para 4.1.2, que o resto não importa mais para você! (😂😂😂) detalhes em 4.1.1.1

[2]: Você é o tipo de Dev que prefere Setup Wizards invés de CLIs ? Evita ao máximo precisar usar terminal ? Não liga para ter/manter o controle sobre sua máquina (incluindo desempenho e performance) ? e informações como CPU Cache, CAS-L não fazem diferença para você ?

Se vc respondeu “Sim” para pelo menos duas das perguntas acima [2], ambas as plataformas lhe fazem sentido. Mas se respondeu “Não” para pelo menos três delas, eu indicaria a plataforma AMD!

4.1.1.1 Por que Intel?

A tecnologia HAXM é exclusiva da Intel, então se algum software que você utiliza usa exclusivamente o HAXM para virtualização, então você está preso à Intel.

Um dos Softwares que usa exclusivamente o HAXM (no Mac OS pelo menos), é o Android Studio. Por ele não esperar por um processador AMD nos Macs obviamente não incluiu o suporte à outras tecnologias de virtualização no seu AVD — Android Virtual Device. Porém se você somente irá usar o Android Studio com HAXM, há outras formas de virtualizar Dispositivos Android sem usar o HAXM. Algumas delas é usar o KVM, QEMU ou até mesmo o AEMU (Android Emulator — Nativo do Android SDK). Outros emuladores também funcionam perfeitamente, como o caso do Genymotion e BluStacks.

Além do HAXM, alguns dos processadores Intel contam com GPU integrada (APU), o que conta muito no bolso no atual momento de elevados preços de GPUs dedicadas. Se por um lado é necessário ter uma GPU AMD para hackintoshes com gráficos dedicados, por outro os gráficos integrados AMD podem causar alguma dor de cabeça para poder funcionar devidamente (ou não funcionar).

Assim concluímos que: se você está montando um Hackintosh sem uma gpu dedicada, por exemplo, um laptop ou desktop com APU, e/ou depende do HAXM para trabalho, e se você não liga para manter o controle de desempenho e performance do seu hack, você deve seguir com Intel.

4.1.1.2 Por que AMD?

Por incrível que pareça e indo contrário ao que o senso comum dita, AMD é a plataforma mais fácil e rápida para fazer Hackintosh em Desktops.

É importante ressaltar dois pontos aqui. Primeiro que me refiro à facilidade de hackin em Desktops, pois em Laptops (Notebooks) com processadores AMD não é se quer recomendável TENTAR fazer. Segundo que levando em consideração o Tópico 4.1.1.1 APUs AMD não são suportadas*.*

AMD é a plataforma principal para o OpenCore, que em minha visão é o melhor Boot Loader para Hackintosh (discutiremos sobre isso logo mais), e por esse motivo, recebe em primeira mão as atualizações de Kexts e Patches e suporte para versões do MacOS. A fabricante por ser OpenSource friendly, muito de suas tecnologias estão disponíveis meio Open source, e isso facilita a vida dos devs no fornecimento de suporte. Outro motivo que facilita o hackin’ é o compartilhamento de microarquitetura entre as gerações dos AMDs, o que faz com que um patches criados para os zens 1 funcione perfeitamente para os zen 2 e zen 3 (Ryzens), e também tenham retro compatibilidade com as microarquiteturas Bulldozer’s (xxx-FX) e Jaguar’s (Athlons e Sempron’s).

Desde o lançamento dos processadores zens a escolha por esses processadores cresceram muito em relação aos de sua concorrente Intel, tanto no meio Gamer quanto no profissional. E é claro que isso devido à suas especificações e tecnologias envolvidas. E tudo isso pode ser usufruído também nos Hackin’:

- Suporte à maiores stock clocks em memórias;
- Melhor multi-threading;
- Melhor desempenho em par com as GPUs;
- Suporte à personalização de desempenho energético da CPU (Cores e Threads);
- Melhor ambiente para entusiastas de hardwares/Softwwares;
- TDP mais baixo (Sim, AMDs são mais frios hoje em dia);
- so on;

Concluindo, com AMD temos o suporte a mais versões do OS X e macOS nativamente, através do OpenCore, e sem procedimentos “dolorosos” que com o Clover e/ou Chameleon temos que implementar. A injeção de Kexts e load de patches, ACPI Tables Mappers, e firmware são “mergeados ” durante o boot, então o diagnostico de erros e problemas são mais evidentes e semânticos, e podem ser facilmente corrigidos. Por fim, você terá mais liberdade e controle para fazer o que bem entender com seus setup, e com exceção do HAXM based softwares, todos os softwares vão funcionar perfeitamente como funcionaria num hackintosh baseado em Intel.

Notas:*
É importante que você estude e entenda como funciona um hackintosh, assim você poderá faze-lo sem muitas complicações, como também dá o suporte ao seu próprio build para futura atualizações do macOS. Caso contrário você só estará pegando Bootloaders de outras pessoas aleatórias e testando se roda, se rodou bem, se não “next one”.
No segundo caso, além de ser um PÉSSIMA prática, que envolve está rodando um software que inicia junto à sua UEFI/BIOS podendo injetar qualquer conteúdo no layer principal de sua máquina (inclusive malicioso), também envolve execução de drivers, extensões de kernel entre outros softwares, diretamente no sistema, que podem sim ter controle do seu ambiente e até mesmo do Apple Store Connect, já que você não faz ideia do que está rolando ali. É importante pensar no pior caso, afinal a depender de seus clientes, o comprometimento desse nível pode lhe gerar grandes dores de cabeça (e caso aconteça, você vai chorar para quem? A Apple? hehehe).
Então ao menos, aprenda o mínimo.*

4.1.2 Hackin on

Primeiramente temos que preparar nosso target: selecionar o HD/SSD que vamos instalar o macOS, separar um pendrive de no mínimo 16GB, um sistema operacional rodando, MacOS, Windows 10, ou Linux, conexão cabeada (Caso você não tenha uma conexão ethernet, um outro guia vai lhe ajudar, linkarei aqui assim que termina-lo), e ter em mãos os nomes dos nossos componentes de hardware (Aida64 e o Google são seus melhores amigos agora). Você DEVE ter os seguintes componentes:

CPU nome e geração
GPUs
HDD/SSD, NVMe e quais configurações: AHCI/RAID/IDE
Modelo de seu Laptop/Desktop (chipset)
Ethernet chipset + WLAN/Bluetooth chipset

Exemplos

# Exemplo Desktop 1:
Ryzen 5 3600
RX 580
SSD NVMe AHCI
B450m
Realtek GbE LAN chip (10/100/1000 Mbit) ou (Chipset Realtek 8111e)
sem Wifi/Bluetooth# Exemplo Desktop 2:
i5 10900k
RX 580
SSD M.2 Sata3 AHCI
B460G
Ethernet Intel I219-V (chipset in-same)
Intel® Wireless AC/AX (chipset Intel N 7265)# Exemplo Laptop (Notebook):
i5 1035G1
UHD Graphics 630 
NVIDIA GeForce MX110 (não usa: tem que desativar)
SSD Sata3 AHCI
s145 ideaPad — lenovo
WiFi 1x1 AC (chipset: AC 3165 )
ethernet não tem

Para conseguir os detalhes do seu hardware em Sistemas baseados no linux basta seguir os seguintes comandos no terminal:

# CPU Model
$ cat /proc/cpuinfo | grep -i “model name”
#GPU Model
$ lspci | grep -i — color “vga\|3d\|2d”
#Chipset Model
$ dmidecode -t baseboard
#Keyboard, Trackpad and Touchscreen Connection Type
$ dmesg | grep -i input
#Audio Codec
$ aplay -l
#Network Controller models
Basic info:
$ lspci | grep -i network
More in-depth info:
$ lshw -class network
#Drive Model
$ lshw -class disk -class storage

Próximos passos

Para os próximos passos temos: baixar uma imagem oficial do macOS diretamente da Apple Store temos duas opções: baixar por um Mac, ou usar uma ferramenta de linha de Comando chamada gibsMac. Com ela conseguimos baixar qualquer versão do sistema e já configurar o OpenCore. E criar o Penboot.

Após fazer o download e criar o Penboot já com o Opencore, devemos criar nossa EFI, que será onde estará todos os patches e drivers necessários para o funcionamento do Hackintosh.
Tudo isso e os Cosmetics Steps será abordado na Parte 2 desse artigo, que será publicado no dia seguinte à publicação desse (Parte 1). Para nos familiarizarmos com os termos e conceitos, recomendo a leitura do nosso “glossário”, que contém os termos que usaremos e sua definições, disponível aqui.

Considerações

A escolha da ferramenta que você usará vai depender exclusivamente de sua necessidade, contexto econômico — se pode investir em um Mac ou em Build Hackintosh, ou pagar um serviço cloud — , e também paciência.

Minhas considerações é que há duas soluções que são as melhores. Estas são: comprar um Mac e o Hackintosh. Considerando usabilidade, estabilidade e suporte. Outra que poderia está nessa lista seria a Virtualização (sousumi / Docker-osx), porém, nesse caso, exige um pouco mais de seu hardware, paciência e conhecimento em manipulação de containers Docker. O hackintosh não fica para trás no quesito “paciência”, mas por outro lado não exige um hardware tão poderoso para um uso aceitável, e por isso é o meu favorito.

Se você tem Dead-lines ou não tem muito tempo para trabalhar em um hackin’, você pode fazer a trilha gradual, partindo inicialmente em Virtualização, e ir construindo seu Hackintosh até que esteja funcional e “estável”. E desde que você saiba o que está fazendo, não haverá sérios problemas com suporte nos próximos 5 anos (no mínimo).

Fala Pessoal, passando aqui para compartilhar com vocês uma reflexão que, tanto por experiencia própia, quanto por em base de meus ultimos estudos na área de Gestão de Times e Projetos, vejo ser uma questão importantíssima que é a saúde mental.

Sei que muito tem se falado, principalmente durante e após o período que enfrentamos nos ultimos anos, mas deixo aqui meus dois centavos de contribuíção a partir de minha perspectiva e de que tenho adotado em meu dia-a-dia como dev.

Prioridade despriorizada

O "ser dev" é muito louco: cheio de emoção, mas também repleto de desafios complexos. No emaranhado de código e reuniões, prazos apertados, features que precisam ser lançadas e "bugs tenebrosos", podem gerar pressões que, muitas vezes, passam despercebidas, e podendo levar a altos níveis de estresse, ansiedade e possivelmente ao esgotamento. Contudo, enquanto buscamos nos aprimorar e evoluir técnicamente na carreira, é fundamental que não negligenciarmos os cuidados com nossa saúde mental e bem estar.

Um ((bind)) poderoso

Assim como consultamos especialistas para melhorar nosso código ou softskills, a orientação de um profissional de psicologia pode fortalecer nossa resiliência emocional. E da mesma forma que temos frameworks, IDEs, workspaces etc para gerenciar memória, escalabilidade e arquitetura afim de extrair performance do software que estamos desenvolvendo, psicologos fornecem um "workspace" onde podemos discutir desafios, gerenciar estresse e desenvolver estratégias para alcançar um equilíbrio saudável entre trabalho e vida pessoal.

Investir na saúde mental, assim como na saúde corporal (mas isso falaremos em outro momento), além de "fazer bem", também pode ser encarada como uma estratégia inteligente para melhorar a produtividade. Uma mente equilibrada é mais capaz de enfrentar desafios mais complexos, ser mais eficaz e criar soluções criativas.

Impacto Positivo

Da mesma forma com que enfrentamos os bugs tenebroso em nossos códigos, também encontramos obstáculos emocionais ao longo de nossa trajetória profissional. Muitas vezes como comportamentos novos, dentre outras coisas: dificuldade de concluir task que aparentemente era simples, falta de motivação em tasks que lhe animava ou simplesmente go blank (e até mesmo aquela vontade de todo dia mandar o cliente lá para a casa do---).

Todos esses comportamentos citados eu passei, e entender a situação, o ambiente, e as possíveis causas me ajudou muito a conseguir a me organizar e me alinhar novamente "nos trilhos".

O suporte psicológico não é um sinal de fraqueza, mas sim uma ferramenta valiosa para lidar com a pressão invisível que muitas vezes carregamos.

Por fim, deixarei o lembrete que aqui é apenas uma sugestão geral e não substitui a orientação de profissionais. Caso esteja passando por desafios emocionais, procure ou peça indicação de um profissional.

Show então, E Até!

#2Articles1Week