teleren/devto huggingface dataset:
On the day I explained to my Uber that it is Clojure
Published: 2023-12-09 17:18:15

Imagine an Uber ride that turns into an unexpected lesson on functional programming. This blog recounts my experience when I decided to share my recent learning of Clojure with my Uber driver. Here are the details of this unusual but fun encounter!

After leaving work, I had to take an Uber to the bus terminal to travel to my hometown. My eyes fell upon a small programming book on the front passenger seat. Curiosity consumed me, and upon asking, I discovered that my driver was delving into the world of programming out of pure passion. The driver's name was Juan.

The conversation naturally flowed towards programming languages, and when I mentioned Clojure, I saw a spark of curiosity in Juan's eyes. "Clojure? I've never heard of it, but it sounds intriguing," he commented, eager to learn more about this hidden gem in the programming realm.

I decided to put theory into practice. As the vehicle moved, I took out my laptop and started writing a modest Clojure program, all while waiting at red lights. "This is a language that promotes elegance and simplicity," I told Juan as I showed him the code

```clojure
(defn greet [name]
  (str "Hello, " name "! Welcome to Clojure."))

(defn -main
  [& args]
  (println (greet "Juan")))
```

As the code came to life on the screen, Juan grasped the simplicity and effectiveness of Clojure, amazed by its concise and functional approach.

Initially, seeing many parentheses seemed confusing and strange to him, as he hadn't had the chance to learn similar languages.

The journey turned into a lively conversation about immutability, first-class functions, and the philosophy behind functional programming. Juan asked insightful questions, and together we explored the unique features of Clojure that set it apart from other languages.

At the end of the ride, I sent Juan the code we created and some resources for him to continue his journey into the Clojure universe. He bid farewell with a grateful smile, ready to explore the magic of this functional language on his own.

This unique experience in my Uber ride was not just a chance encounter but also an opportunity to share knowledge and ignite a passion for programming. Who would have thought that a simple Uber ride would turn into an educational and exciting adventure?

And so, our story about the day I explained to my Uber driver what Clojure is concludes. Have you had a similar experience? Have you found yourself sharing your love for programming in unexpected situations? Share your stories in the comments, and let's continue exploring the thrilling world of code together! Until the next journey!
Uncovering a Common Challenge in React Native: Reducing APK Size 🚀
Published: 2023-12-09 17:12:05

Hello, LinkedIn community! 👋

Today, I want to share a recent experience developing with React Native and address a common problem that many of us face: the large size of the generated APK.

**🤔 The Problem:**

When building robust React Native applications, we often come across considerably large APKs. This issue can impact performance, user experience, and even make submission to app stores difficult.

**💡 One solution:**

I recently discovered an effective approach to significantly reduce APK size, especially in projects that make extensive use of libraries or dependencies.

**1. Bundle Splitting:**

I implemented "bundle splitting", dividing the code into smaller parts. This allows only relevant sections to be loaded on demand, reducing the initial size of the APK.

```
// Example of configuration in the file metro.config.js
const { createBlacklist } = require('metro');

module.exports = {
  resolver: {
    blacklistRE: createBlacklist(/\.server\.(js|ts)$/),
  },
};
```

**2. Removing Unused Resources:**

Audited and removed unused resources such as non-essential images, fonts, or libraries. React Native Resource Clean is a useful tool for this task.
 
```
npx react-native-resource-clean
```


**🌐 Results:**

These optimizations reduced APK size by more than 30%, significantly improving app performance and easing the submission process.


**💬 Share your Experience:**

Have you faced similar challenges in React Native? How do you address these issues? Let's exchange experiences in the comments! Together, we can create more efficient applications and improve our React Native skills. 🚀
My Top Angular Kendo Articles 2023
Published: 2024-01-08 15:50:43

---
title: My Top Angular Kendo Articles 2023
published: true
date: 2023-12-09 17:04:42 UTC
tags: 
canonical_url: https://www.danywalls.com/my-top-angular-kendo-articles-2023
---

As 2023 comes to an end, I find myself reflecting on the valuable lessons and knowledge I've gained through writing. In addition to this blog, I create content for [Telerik Kendo](https://www.telerik.com/blogs/author/dany-paredes). Today, I'm excited 😊 to share with you my top Kendo UI articles from this year.

Let's look at them together!

1. **📊 Building Your Own Scrum Board with Kendo UI for Angular** : This article shows you how to add drag-and-drop features to Angular apps easily. You can even make your own scrum board. It gives you easy steps to follow. [Read 📑](https://dev.to/telerik/how-to-build-your-own-scrum-board-with-kendo-ui-for-angular-drag-and-drop-2fdo-temp-slug-4145036)

2. **🔄 Harnessing the Power of Directive Composition API in Angular 15 with Kendo UI** : Jump into the world of directives and learn how to use them again and again in Angular. This is really helpful for making complex directives and making Angular templates simpler. [Read 📑](https://dev.to/telerik/use-the-powerful-directive-composition-api-in-angular-15-with-kendo-ui-4n8e-temp-slug-1133900)

3. **📈 Manipulating Data in Angular with Kendo UI Data Query** : Learn how to work with data in Angular. This includes sorting, filtering, grouping, and adding things together. This is very important to make your Angular projects better. [Read 📑](https://dev.to/telerik/manipulating-data-in-angular-with-kendo-ui-data-query-4phm-temp-slug-4544741)

4. **🔨 Guide to Building a Component Library in Angular** : Find out how having a library of components can make your work faster. This detailed guide helps you start your own component library in Angular. [Read 📑](https://dev.to/telerik/angular-component-library-part-1-how-to-build-a-component-library-with-angular-5fbc-temp-slug-5109051)

5. **🎨 Theming and Publishing Your Angular Library to npm** : This article is about how to make your Angular component library better by putting it on npm and giving it different theme options. [Read 📑](https://dev.to/telerik/angular-component-library-part-2-how-to-theme-and-publish-your-library-to-npm-1abm-temp-slug-4072212)

6. **Enhancing Your Company Library with Kendo UI** : Learn the benefits of using a professional component library like Kendo UI in making apps. It makes every part of app making easier and better. [Read 📑](https://dev.to/telerik/angular-component-library-part-3-power-up-your-company-library-with-kendo-ui-15gf-temp-slug-2683601)

As we say goodbye to this year, I want to thank Progress Telerik, Alyssa Nicoll, and Mandy Mowers so much. They helped and supported me a lot, and it was very important for my success this year 🌟.

If you want to read more, you can look at all my articles [here](https://www.telerik.com/blogs/author/dany-paredes).

Let's keep learning and growing in tech together! 💡📚
Desvendando um Desafio Comum no React Native: Reduzindo o Tamanho do APK 🚀
Tags: javascript, reactnative, mobiledevelopment, optimizationtips
Published: 2023-12-09 16:56:28

Olá, comunidade do LinkedIn! 👋

Hoje, quero compartilhar uma experiência recente no desenvolvimento com React Native e abordar um problema comum que muitos de nós enfrentamos: o tamanho volumoso do APK gerado.


**🤔 O Problema:**
Ao construir aplicativos React Native robustos, frequentemente nos deparamos com APKs consideravelmente grandes. Essa questão pode impactar o desempenho, a experiência do usuário e até mesmo dificultar o envio para lojas de aplicativos.

**💡 A Solução:**
Recentemente, descobri uma abordagem eficaz para reduzir significativamente o tamanho do APK, especialmente em projetos que fazem uso extensivo de bibliotecas ou dependências.

**1. Bundle Splitting:**

Implementei o "bundle splitting", dividindo o código em partes menores. Isso permite que apenas as seções relevantes sejam carregadas sob demanda, reduzindo o tamanho inicial do APK.

```
// Exemplo de configuração no arquivo metro.config.js
const { createBlacklist } = require('metro');

module.exports = {
  resolver: {
    blacklistRE: createBlacklist(/\.server\.(js|ts)$/),
  },
};
```

**2. Remoção de Recursos Não Utilizados:**

Auditei e removi recursos não utilizados, como imagens, fontes ou bibliotecas não essenciais. O React Native Resource Clean é uma ferramenta útil para essa tarefa.

```
npx react-native-resource-clean
```

**🌐 Resultados:**
Essas otimizações reduziram o tamanho do APK em mais de 30%, melhorando significativamente o desempenho do aplicativo e facilitando o processo de submissão.

**💬 Compartilhe sua Experiência:**
Você já enfrentou desafios semelhantes no React Native? Como você abordou essas questões? Vamos trocar experiências nos comentários! Juntos, podemos criar aplicativos mais eficientes e aprimorar nossas habilidades no React Native. 🚀
Mining Adventure V.0.1
Tags: codepen, javascript, html, css
Published: 2023-12-09 16:53:15

Cant Wait For You To Check My Game Out Called Mining Adventure V.0.1 (Version 0.1)
Obviously it will not be the best, but this is just the first version. Please leave any suggestions, feedback etc.. in the comments. Please enjoy the game!

_---------------------------------------------_

- {% codepen https://codepen.io/Leland-the-styleful/pen/bGzZLON %}

-______________________________________________-


Copyright (c) 2023 by Leland (https://codepen.io/Leland-the-styleful/pen/bGzZLON)

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Community Management And Content Creation
Tags: javascript, webdev, community, techtalks
Published: 2023-12-09 16:44:21

📌 Community Management in Tech

We Talked About👇

- Community Manager Role
- Community Building 
- How to Monetize Community 
- Content Creation  
- Hackathon & Event Management 

Watch here 👀
{% youtube https://youtu.be/WEV6Pk99ufs?si=XeHmmGzalM1dPT8Z %}
React's Unexpected Offspring: How the Web Gave Birth to React Native
Tags: javascript, react, reactnative, beginners
Published: 2023-12-09 16:36:52

#####A Tale of Innovation and Unintended Consequences

In the ever-evolving world of technology, unexpected twists and turns can lead to groundbreaking advancements. Such is the story of React Native, a revolutionary framework that emerged from the fertile ground of the web. Unlike its parent, React, which reigns supreme in the realm of web development, React Native unexpectedly ventured into the seemingly distant territory of mobile apps, defying expectations and rewriting the rules of the game.

This captivating journey began with the phenomenal rise of React. Its declarative nature and component-based approach brought order and elegance to the chaotic world of web development. Engineers were captivated by its simplicity and efficiency, leading to its widespread adoption by companies like Facebook and Netflix.

However, amidst this web-centric triumph, a hidden yearning for a mobile experience began to stir. Developers craved the power and flexibility of React on their smartphones and tablets. This yearning, initially dismissed as a mere pipe dream, planted the seeds for a daring experiment - to bridge the gap between web and mobile, to bring React's magic to the world of apps.

Enter React Native, the unforeseen offspring of this ambition. It was a bold move, a daring attempt to transplant the DNA of web development onto the fertile soil of mobile platforms. And it worked. React Native seamlessly integrated with native components, allowing developers to write JavaScript code that could be rendered across iOS and Android platforms.

This unexpected birth was met with both excitement and skepticism. Some saw it as a game-changer, a revolution in mobile app development. Others questioned its viability, highlighting the potential challenges of adapting a web framework to the demands of native platforms.

But React Native defied the naysayers. Its intuitive API, combined with the familiar React syntax, made it a breeze for web developers to build mobile apps. The rapid iteration cycle, a hallmark of React, found its way onto mobile, allowing developers to experiment and innovate with newfound speed and efficiency.

Today, React Native stands tall as a testament to the unpredictable nature of innovation. It has empowered developers to create a new generation of mobile apps, apps that are not only beautiful and engaging but also built on a foundation of speed and efficiency.

As we look towards the future, the story of React Native serves as an inspiration. It reminds us that sometimes the most unexpected ideas can lead to the most groundbreaking advancements. It encourages us to embrace the unknown, to experiment and explore, for in the fertile ground of uncertainty, the seeds of revolutionary innovation may lie hidden, waiting to be discovered.
Operating system
Tags: webdev, programming, tutorial, beginners
Published: 2023-12-09 16:05:35

Embarking on the OS Challenge!
#Day_1 Exploring Operating Systems.

Today, we dive into the fundamentals with an Introduction to Operating Systems.

🖥️ What is OS?
An Operating System is a crucial software piece managing a computer's resources, both hardware and software. It creates an environment for users to execute programs conveniently and efficiently, masking the hardware complexities and acting as a resource manager.

💡 Importance of OS:
Imagine a world without OS—applications would become bulky and complex due to hardware interaction code embedded in the app's code base. Without memory protection and resource management by an OS, one app could exploit resources.

🔍 What makes up an OS?
It's a collection of system software, a dynamic ensemble working seamlessly.

💼 OS Functions:
Access to computer hardware.
Interface between users and computer hardware.
Resource management (memory, devices, files, security, processes, etc.).
Hides hardware complexities (Abstraction).
Facilitates application execution by providing isolation and protection.

📚 Key Terms:
Application Software: Performs specific tasks for users.
System Software: Operates and controls the computer system, providing a platform for application software to run.


Ready for the OS journey? Stay tuned for more insights! 🚀 #OSChallenge #OperatingSystems #TechExploration #lovebabbar
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/cthfnmot71zosl9ozc7k.jpg)
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/qscbwcydd6ma4rbn7tvg.jpg)


#Day_2 of the OS Challenge!
Today, let's delve into the diverse world of Operating Systems and their goals:

🚀 OS Goals:
Maximum CPU Utilization
Minimized Process Starvation
Efficient Higher Priority Job Execution

💡 Types of Operating Systems:

Single Process OS [MS DOS 1981]
Oldest form where only one process executes at a time from the ready queue.

Batch-Processing OS [ATLAS, Manchester Univ.]
Jobs are prepared by users, submitted to operators, sorted into batches, and processed together.

Multiprogramming OS [THE, Dijkstra, early 1960s]
Maximizes CPU utilization by keeping multiple jobs in memory, reducing idle time during I/O.

Multitasking OS [CTSS, MIT]
Logical extension of multiprogramming, enabling simultaneous execution of tasks and reducing CPU idle time.

Multi-processing OS [Windows NT]
Utilizes more than one CPU in a single computer, enhancing reliability and throughput.

Distributed System [LOCUS]
Manages resources across autonomous, interconnected computer nodes, fostering collaboration.

Real-Time OS [ATCS]
Ensures error-free computations within tight time boundaries, vital for applications like air traffic control and robotics.

The OS landscape is vast and dynamic. Stay tuned for more OS insights! 🖥️ #OSChallenge #OperatingSystems #TechJourney #SoftwareDevelopment
'return await' in a try/catch
Tags: javascript, node, eslint, webdev
Published: 2023-12-09 15:59:02

This might sound weird to you, the first thing that comes to mind is: 'Eslint will tell me to remove the await, there is no need for an await after a return'

But the case is a different when we wrap our promise in a `try/catch`.

```js
async function foo() {
  try {
    return await waitAndMaybeReject();
  } catch (e) {
    return 'caught';
  }
}
```

This also applies when we don't need to return resolved value of the promise, **we always need to await it if the returned promise is inside a `try/catch` and we want to catch the error**.

By returning a promise, we’re deferring its result, so our catch block never runs.
This also happens, when not awaiting a promise (regardless if we return or not).


> Only outside of try/catch blocks, `return await` is redundant. There’s even an [Eslint rule](https://eslint.org/docs/latest/rules/no-return-await), but this rule allows a return if it's in `try/catch`.


---

## Bonus🔥

If you want to print something after a return statement, instead of temporaraly creating a variable, printing and then returning, like this:
```js
async function foo() {
  const res = await fetch();
  console.log('after fetch')
  return res;
} 
```
We can wrap the return with a try and finallly (unless you need to print the resolved value of the promise of course), like so:

```js
async function foo() {
  try {
    return await fetch();
  } finally {
    console.log('after fetch')
  }
} 
```
Tmux - A Multiplexer Screen Viewer
Published: 2023-12-09 15:58:50

- Terminal Multiplexing ( Tmux )
- Helps to run the program simultaneously.
- The whole screen and can be divided into rectangular panes.
- Its a concept for sessions in the screen.

## How to Install in Ubuntu

```
sudo apt-get install tmux
```
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/lgme8feowjy91vg0uhhg.png)
```
One by one execute the below command:

tmux
Control + B
D 
```
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/op5zbjmbtqaqcx0z3jnr.png)

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/q8jd2l9fbvikgri6h2y4.png)

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/7nhgy7kmznnfdvsvfuvh.png)

## Help

```
tmux
control + b
?
```

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/vn1ppzxu6825gntspvun.png)

## Panes

```
tmux
control + b
% ( control + % )
```

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/rat0vauvyvkff0n0kkti.png)

```
control + b
" ( control + " )
```

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/5oj065g4zpf6kmduryd4.png)

**<u>_Moving across the Panes_</u>**

```
control + b
Arrow 
```

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/myzgwcj3h9vcd3awi2bg.png)

**<u>_Resize the Panes_</u>**

```
control + b ( hold it )
Press the Arrow
```

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/p876btgagfgzmbppl32z.png)

## Screens

```
Control + B
C
```

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/vy15tcu2qyce2pxqr83n.png)

**<u>_Switch between screens_</u>**

```
control + b
n ( Next )
P ( Previous )
```

### Reference

1. https://www.fosslinux.com/58586/install-and-use-tmux-on-linux.htm

2. https://www.youtube.com/watch?v=e-ra8fSaSkQ&list=PLTY9BjMMGESF20iLUIMncEN1UVLJocD3T
Project Nine: Chat
Tags: webdev, beginners, challenge, codingquokka
Published: 2023-12-09 15:49:52

Have you sent or received any messages today? I bet you did and therefore are very familiar with instant messengers.

If not - I can recommend chatting with ChatGPT or AwarefyAI - those two are great friends of mine (and half of the globe it seems).

What do you think about implementing a chat today? Something simple and stylish, just to deep your feet into working with streams of events.

In your future work you could quickly swap source of events and adapt it to a variety of needs from comments and social media posts to real-time communication and AI helpers.

## Chat Window: requirements and recipe

> As a user I want to be able to send and receive messages, so that I can quickly communicate with an interlocutor

Here's an example of how a chat window can look like:

![ChatGPT conversation where I'm proudly bragging of making it to the 9th advent project despite of having hard time doing it](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/nb1miqg2u3cg41y2vebi.png)

There are many ways how you can make a chat work and since the goal is to have a "white label" solution that you can adjust for specific needs - we can start with the basic requirements:

### Requirements

1. There should be an input that allows one to send messages
2. Chat window should show text messages that you've sent
3. Chat window should show text messages that you've received
4. Chat window should be accessible and notify screen reader on each new event

### Recipe
1. Design and layout a static message
2. If you'd like messages vary between those user sends and receive - layout static examples of those variations
3. Create input for user to send messages
4. Combine everything in a static chat prototype
5. Ensure that the chat is accessible
6. Hook the chat up to an event
7. Have a nice conversation with yourself

### Hints

If you don't want to create a backend for a chat - you can use `localStorage` or `window.postMessage` to communicate between two tabs.

Use live regions or a specific role to ensure accessibility.

Think about different states of messages: what happens if a message fails to be sent for example? Are there any other states you'd like to incorporate?

## Hard mode: Web Real-Time Communication Chat

There's not much going on in the local chat, isn't it? Luckily for us there's a whole [WebRTC API](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API) available in every major browser.

Of course, to make it work you would in fact need a server, but after all - World Wide Web wouldn't be possible with just one computer. Do you think you can take on this challenge?

Share your creations and feedback and see you tomorrow!

Liked the idea a lot and would love to have it all year long?

[![Buy Me A Coffee](https://cdn.buymeacoffee.com/buttons/v2/default-red.png)](https://www.buymeacoffee.com/valeriavg)