teleren/devto huggingface dataset:
Refactoring, and Rebase
Published: 2021-10-16 01:34:58

# Refactoring codes
This week is a good time for me to take a look back at my project to make some improvements. My program is working as expected but my codes are not clean and optimized. There are still a lot of redundant codes of testing stage, repeating codes and some ambiguous variable names.
Firstly, I created a new branch name <code>refactoring</code> then wrapped all duplicated codes up into a function. Then call that function in appropriate places. Variable naming is important in professional programming. It makes your codes more easily to understand when other people try to read them or when you want to look at your codes to make some changes. If you name your variable <code>a</code> which stands for <code>array</code>, other people might misunderstand it and they might think <code>a</code> is <code>argument</code>. This also the same with naming functions. In the end, all the names of variables and functions are now more clear and understandable. Lastly, I deleted all the <code>console.log</code> that I created while testing to make my code neat and look more professional.

# Git Rebase
Each time I finished an improvement, I committed that step. After testing my tool many times to make sure it still works, I <code>git rebase main -i</code> to move my recent commits to the top of the sequence of commits. With option <code>-i</code>, my command will do an interactive rebase to allow me to choose what to do with my commits. I picked <code>pick</code> for the latest commit and the others are <code>squash</code> so that they will attach to one commit only. Finally, I did <code>git commit --amend</code> to modify my latest commit last time and merge the <code>refactoring</code> to <code>main</code> then <code>push</code>.
Git rebase is beneficial for maintaining a clean history of your project. With git rebase, your branching workflow is easily visualized, since you can rebase your old branches to the top so that you can start fixing and debugging your codes with ease.

# Links
Github repo: https://github.com/nguyenhung15913/OSD600-SSG
Final Merge commit: https://github.com/nguyenhung15913/OSD600-SSG/commit/e27246018b2bf325c25f5a63fdae1994f8e0990b
Contributed to some OSS with pull-requests in this year  at Hacktoberfest
Tags: hacktoberfest, hacktoberfest2021
Published: 2021-10-16 01:17:42

## Hacktoberfest 2021

I participated in hacktoberfest again this year. I attended for the first time last year, and I feel that this is one of the best opportunities for me to contribute to open source.

## Contributions
I will write about the Pull Requests that I contributed to at Hacktoberfest.

### surajondev/get-weather
https://github.com/surajondev/get-weather/pull/7

This pull-request fixes react warnings and typo.

### TDrake38/tool-swappin
https://github.com/TDrake38/tool-swappin/pull/41

This pull-request fixes some React warnings.

### aralroca/fragstore
https://github.com/aralroca/fragstore/pull/7

`yarn-error.log` was managed by Git, so this pull-request fixes to remove it from management.

### taitems/user-email-enrichment
https://github.com/taitems/user-email-enrichment/pull/13

This pull-request  added basic testing with Jest.

## Lots of interesting OSS

I usually tend to focus on my own projects, but when I look at other people's projects like this, I am reminded that there are many interesting OSS.
That is very exciting🚀
This is the reason why I prefer having a mentor over buying expensive courses!
Tags: tutorial, startup, beginners
Published: 2021-10-16 00:55:52

This may sound cliché to you but I'm sure many of us have experienced the same thing. I myself just got a job as a front end and 3d programmer at a startup. This startup only has 4 employees including me. The other employees already have 5-10 years of experience, only me as a fresh graduate. In my journey as a junior I encountered many obstacles. Lately the problem is that I have to face to face with a CEO who is very critical and has a lot of requests. it makes a burden for me. The way I solve this problem is to tell my abilities indirectly. I think it's normal to feel unsure of your own abilities because you don't have experience. At that point, I felt very deprived and didn't know where to turn for help.

The other 2 programmers are very reliable backend programmers. They are very confident in what they are doing. here I am like Joma Tech and they are the subscribers. But they couldn't help me much because they were also busy with their own work. Again I feel more and more pressure because accompanying those who are already very senior. One thing I believed in at the time was that I had to improve.

But everything changed when a senior front end with 4 years of experience came. He is very good at logic and has a solid knowledge of the fundamentals. This is where I aspire to be like him. I started learning to imitate his coding style and the way he solves problems. One thing I admire about him is that he is willing to teach other people. That makes me even more determined to say there is no need to buy expensive courses as long as you have seniors who can teach you many things. If I have money, I'd rather treat my senior than having to buy a new course!.
My first contribution to a open sources
Tags: opensource
Published: 2021-10-07 21:12:06

## Intro
For release 0.2, we are participating in the Hacktoberfest. I started to search for some issue with the label "good first issue" and I end up with one issue in the [WordPress](https://github.com/WordPress/openverse-frontend) repo. 
The issue was [[Bug] Remove button styling from "no results" text #215](https://github.com/WordPress/openverse-frontend/issues/215). I started to ask if I could work on it. Then once the issue got assigned to me I started to work on it. The most challenging part of this issue was to learn Vue.js. With my background with other frameworks, the way how Vue.js works look like React.js but the syntax was different.

First I fork the repo, then clone it and install all packages needed to run in my local.
After being able to run my code locally I started to play around to familiarize myself with the app.
I started to locate the component for the search bar. After finding it I started to think about the logic of how am I fixing this bug. The way to fix this bug is to check if the query returns something, if it doesn't show "No image results for "query"." otherwise show the image.
I also removed the old no image button stated in the issue requirement.

After the issue was fixed. I run some automation testing once everything passes. I can commit my code and submit a pull request [PR](https://github.com/WordPress/openverse-frontend/pull/272).

I had some issues where openverse.pot file using my absolute path instead of a relative path. One of the code reviewers reverts that file. This issue ended up being a bug in windows [Fix Windows full path in .pot file #290](https://github.com/WordPress/openverse-frontend/pull/290).

## Conclusion

The bug wasn't something complex, but the learning outcome from this issue was very useful. It gave me confidence that I can learn some other framework fast.
What JDK should we use in 2021?
Tags: discuss, java, programming
Published: 2021-10-16 00:13:53

Hi all, hope you're doing well.
I've been working with Java for quite some years, and it may not come as a surprise to some, that Java is undergoing a lot of changes in its API, and approaches to most things in the recent years. 
Me, I'm the (stubborn?) kind of developer that learns much more from practice than reading. And while I do dig into new repos and tech trends every so often, I did not realize the -many- new & exciting things you can do with Java today.

You see, I have been building an open-source eCommerce backend using JDK 8 for the last two years. So for example, JDK 8 introduced Streams, which I'm not yet used to, but I love the idea (I'm pretty into RxJS in the frontend). 
And today we have JDK 11 already, which feature the very useful, simple, and obvious method `String.isBlank()` method and who knows what else. And, **damn me, that isn't even the latest JDK to date...** That's JDK 17, apparently?!

It made me think about how complicated things can become; having to keep up with these new APIs and giving fellow developers the need/task to document themselves to read code that otherwise may be written in a more traditional manner (in Java at least). And of course, backwards compatibility! Most Java I've had on a screen was very backwards-compatible code AFAIK (as far as I've known).

Now don't get me wrong, I like going forwards, seeing progress over time and tapping the ladder of knowledge, but **I'm not sure how good of an idea is to switch to newer JDKs**, and how it affects having other people (specially newcomers) delve into the code I've written. I'd rather stick to the most prominently used version so that most people can step right in and contribute.

So, lovely readers, I would appreciate any advice, suggestions, comments, on this. I'm open to new perspectives, but **what I'd really like is a good argument on why to use a newer JDK than 11, at least*.* Is it safer? Is it better optimized? Is it like, just a good standard? And why?

Thanks in advance for reading this post. I'm not often a writer. Looking forward to read what you have to say 👀

`Oh and if you guess what the cover image is from, you get free swag!` 😎😎😎
EDIT: when I wrote this I didn't know they called it `swag` to stickers, badges or similar collectible items, I thought it was just synonymous to the act of recognizing other people :S my bad!

EDIT 2: https://whichjdk.com exists! Check it out, you'll find the answers you need in it.
AI & Data Career Pathways Deconstructed
Tags: career, ai, datascience, nlp
Published: 2021-10-16 00:04:08

**Lack of clarity** when deciding a career pathway, can be really stressful 😓 I have been receiving many questions and seeing a lot of **confusion** on this topic, so instead of continuing to answer individual questions, I decided to address them once and for all.

Developing an AI project is not a one person feat. It involves various technical roles and tasks. In this video I deconstruct them both and also go over **skills needed** and **tools used** in industry. 

✔️**Tasks** covered: Data Engineering, Modeling, Deployment, Business Analysis, Infrastructure, Research
✔️**Roles** compared: Data Analyst vs Data Scientist vs Applied Scientist vs AI Researcher vs ML Engineer vs Software Engineer 


{% youtube ZIBLgPsE8tA %}
  

*With the hope that you find this concise yet comprehensive walk-through helpful and you are walking away with clarity and can make informed career decisions*.

*Best of luck with the journey ahead!* 🌟

---

P.S. You can help me reach out to **others who might benefit** from it as well by showing this post some ❤️ and don't forget **[subscribe](https://www.youtube.com/channel/UCItMkae8zqx4owHuE7l6zZA?sub_confirmation=1
)** to my YouTube channel for more such content.

P.P.S. Let me know in the comments on YouTube, if there are any other topics that you would like me to cover next :)
My thoughts on SAFe (The Scaled “Agile” Framework)
Tags: safe, agile, scaledagile, enterpriseagile
Published: 2021-10-23 19:39:58

---
title: My thoughts on SAFe (The Scaled “Agile” Framework)
published: true
date: 2021-10-16 00:00:00 UTC
tags: safe,agile,scaledagile,enterpriseagile
canonical_url: https://jhall.io/archive/2021/10/16/my-thoughts-on-safe-the-scaled-agile-framework/
---

[SAFe](https://www.scaledagileframework.com/) is a hot topic. Every once in a while, someone asks me my thoughts on the topic. And while ostensibly, SAFe may only apply to large enterprises, it also seems to get some traction even in small companies. I once worked with a company using SAFe for just 3 Scrum teams.

I have two core thoughts about SAFe:

1. SAFe is a terrible name, becuase there’s very little “agile” about it. As I’ve [said before](https://jhall.io/archive/2021/10/14/can-we-scale-agile/), I think the very concept of “scaling agile” is flawed. Maybe I’ll start calling it S\*Fe for that reason. 🤔

If you don’t believe me, I challenge you to pull up [S\*Fe](https://www.scaledagileframework.com/wp-content/uploads/2021/01/SAFe_5.1_Portfolio_SAFe_ImageMap.png) next to the [Agile manifesto](https://agilemanifesto.org/) and do your own comparison. Here are a few of my highlights:

| Agile Manifesto | S\*Fe |
| --- | --- |
| Individuals and interactions over processes and tools | A very complicated process |
| Customer collaboration over contract negotiation | Barely mentions the customer at all (only once in the standard chart) |
| Responding to change over following a plan | Built on an 8-12 week plan |

2. S\*Fe can still be a big improvement for companies that have a slow, bureaucratic process.

Just because something isn’t completely “agile” doesn’t mean it’s _bad_, right? If your organization is benefiting from S\*Fe, don’t be ashamed. Embrace what works.

I just hope you’ll also be free to explore new options when S\*Fe is outgrown at your organization!

* * *
_If you enjoyed this message, [subscribe](https://jhall.io/daily) to <u>The Daily Commit</u> to get future messages to your inbox._
Self Learning or Official Course Training
Tags: discuss
Published: 2021-10-15 23:34:32

---
title: Self Learning or Official Course Training
published: true
description: 
tags: #discuss
//cover_image: https://direct_url_to_image.jpg
---
Hi All,
did you feel that self learning, some times will feel lost in the learning journey compare to official course training?

Any better suggestion for self learning?
Introducing Modzy's AI Hackathon
Tags: ai, webdev, hackathon
Published: 2021-10-15 23:05:39

Hi Everyone! 
My name is Ray and I'm the lead software architect over at [Modzy](https://bit.ly/3aI4WV5). I'm excited to share that we have kicked off our Modzy AI Hackathon! 

## What is Modzy?
Created by developers for developers, Modzy is an MLOps platform for data scientists and developers to deploy, integrate, run and monitor AI models at scale. 

We have written Modzy as an API-first product, and provide extensive [documentation](https://docs.modzy.com/docs) for developers to familiarize themselves with Modzy's capabilities. 

For further ease of use and integration, we've released a number of open source SDKs in [Java](https://github.com/modzy/sdk-java), [Python](https://github.com/modzy/sdk-python), [JavaScript](https://github.com/modzy/sdk-javascript), and [Go](https://github.com/modzy/sdk-go), and certainly welcome any and all contributions that may arise through their use in the competition. 

## The Hackathon
The competition runs through December 1, 2021. Hack together the best AI-powered app, bot, integration, library, or other solution using Modzy’s APIs and SDKs, and you could win a piece of the $25K prize pool, a chance to meet with our judges, and more! Submissions will be judged on the technical implementation, use of Modzy, potential value, and quality of the idea. Join the Modzy community and put your development skills to the test by [registering here](https://www2.modzy.com/dev-to). Good luck, and we look forward to seeing what you build!
Trending: Chrome console features as stand-alone products
Tags: webdev, product, decodingcoding
Published: 2021-10-15 22:58:11

---
title: Trending: Chrome console features as stand-alone products
published: true
description: The poor UX of the browser console means many opportunities for stand-alone productivity apps
tags: webdev, product, decodingcoding
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ct2d71rel61mk0a2r153.jpg
---

### *The poor UX of the browser console means many opportunities for stand-alone productivity apps*

---

Interesting observation: Makers are abstracting out individual features of the Chrome browser console and enhancing them into better, stand-alone productivity apps for designers and developers. Here’s examples I saw:

* [Sizzy](https://sizzy.co/) allows you to inspect different screen sizes for their website or app at a glance.
* [CSS Scan](https://getcssscan.com/) is the fastest and easiest way to inspect and copy CSS of any element.
* [PixelSnap](https://getpixelsnap.com/) is a tool to measure the pixel length of anything on the screen.

Getting the information that these apps provide can be done on the console itself of course, but the UX of it on Chrome is clunky and clumsy. These apps abstract out the individual features and improved on them, making it more seamless and easy to use or view.

That made me think: is there anything else that we need on the console that can become stand-alone, point-and-click products?

* Inspect JS scripts?
* Inspect animations and animation speed?
* Inspect on screen sizes for all brands of mobile, tablet and monitor screens? (like this table of information [screensiz.es](http://screensiz.es/))
* Check for accessibility?
* Check network/performance?
* Check underlying CMS/template used?
* Check for security?
* Check for whois?  

I’d recently been brainstorming on products to make, so this is an interesting angle to go on. It also made me wonder: is there any product that we use right now that has lots of features but has complex and clumsy UX, of which we can abstract out a few of the most commonly used features into stand-alone products? For example, [remove.bg](https://www.remove.bg/) does one thing really well that you can do in clunky Photoshop - remove the background of any image. 

*What other popular tasks do we do on apps like Photoshop or Chrome console that can be abstracted out and made better?*

---

Follow my daily writings on [Lifelog](https://golifelog.com/goals/30), where I write about learning to code, goals, productivity, indie hacking and tech for good.
DPS909 - Lab 5
Published: 2021-10-15 22:47:15

This weeks lab included us refactoring our code. The point was not to introduce new functionality or features, but rather instead clean up our code. I chose to do three improvements to my static site generator, which included reducing code duplication through the use of functions, improving variable names, and separating the main logic from the conversion functions.

### Functions - Reducing Code Duplication
This was the hardest part of the lab. I essentially had to rewrite my code, all whilst testing every code change. I was able to reduce my code duplication by a large amount. This was achieved by creating a few functions that accepted parameters from the main logic, and allowed me to create html files in a simpler way. By doing these mandatory steps, my code is a lot more readable, which means that if someone wanted to contribute to my open source project, they would have an easier time doing so.

### Improving Variable Names
Some of the variable names within my code were very confusing, so much so that I had other developers ask for clarification on the meaning behind them. I took the initiative during this lab to make them more understanding.

### Separating the Main Logic
In my last refactoring step, I took the chance to split my main logic code from the bulk of the other code. This means that now there are two files, one being a utility file, which contains all the functions needed to operate my static site generator, and the second being the __main__ , which holds the argument parsing, etc.

Overall, the git rebase and squashing was pretty straight forward. Here is a link to the [commit](https://github.com/roman-rezinkin/RomanStaticSG/commit/d7fba985840c60241f572285818428db685896a5)...
Array.prototype.filter()
Tags: javascript, filter, array
Published: 2021-10-15 22:38:31

# What is filter?

> The **filter()** method **creates a new array** with all elements that pass the test implemented by the provided function.
> -MDN

# How does filter work?

>`filter()` calls a provided `callbackFn` function once for each element in an array, and constructs a new array of all the values for which callbackFn returns a value that coerces to true... Array elements which do not pass the `callbackFn` test are skipped, and are not included in the new array.
>-MDN

# Syntax

Arrow Function

```javascript
filter((element) => { ... } )
filter((element, index) => { ... } )
filter((element, index, array) => { ... } )
```
Inline Callback Function
```javascript
filter(function callbackFn(element) { ... })
filter(function callbackFn(element, index) { ... })
filter(function callbackFn(element, index, array){ ... })
```

`callbackFn`:
this is a function evaluate the `element` passed in. It returns `true` or `false` for the `element` depending if they meet or do not meet the condition, respectively.

it accepts 3 arguments: 

   * `element`: The current element being processed in the array.
   * `index` (optional): The index of the current element being processed in the array.
   * `array` (optional):The array filter was called upon.


# Examples

Example 1.

```javascript
const names = ['judy', 'joey', 'devon', 'charlie', 'sanjay']
let jNames = names.filter(name => name.indexOf('j') >= 0)

console.log(jNames);
//expected output: ['Judy,'Joey','Sanjay']
```
Example 2.

```javascript
const vegis = ['tomato', 'garlic', 'green onion', 'asparagus', 'avocado']
let shortVegi = vegi.filter(vegetable => vegi.length() < 7)

console.log(shortVegetables)
//expected output: ['tomato', 'garlic']
```
SQL vs NoSQL
Tags: sql, database
Published: 2021-10-15 22:25:27


If you are a beginner wondering what are use cases for SQL or an experienced developer trying to make a choice between SQL or NoSQL for your next project, this article might help you steer your decision the right way.

###Pros vs cons###

*Everything comes at a cost.*

While SQL is **ACID** ( Atomicity, Consistency, Isolation, Durability) compliant which ensures that performed transactions are always consistent, it might be an overkill for your use case.
* Atomicity - ensures that each database transaction is a single unit that adopts an "all or nothing" approach to execution. If any statement in the transaction fails, the entire transaction is rolled back
* Consistency – A processed transaction will never endanger the structural integrity of the database.
* Isolation - Transactions cannot compromise the integrity of other transactions by interacting with them while they are still in progress
* Durability - The data related to the completed transaction will persist even in the cases of network or power outages.

Instead you might find **BASE** ( Basically available, Soft state, Eventual Consistency ) NoSQL databases to be more of a fit.
* Basically available - The NoSQL database approach focuses on the availability of data even in the presence of multiple failures. It achieves this by using a highly distributed approach to database management. Instead of maintaining a single large data store and focusing on the fault tolerance of that store, NoSQL databases spread data across many storage systems with a high degree of replication. In the unlikely event that a failure disrupts access to a segment of data, this does not necessarily result in a complete database outage.
* Soft state - Due to the lack of immediate consistency, data values may change over time. The BASE model breaks off with the concept of a database which enforces its own consistency, delegating that responsibility to developers.
* Eventual Consistency - The only requirement that NoSQL databases have regarding consistency is to require that at some point in the future, data will converge to a consistent state. No guarantees are made, however, about when this will occur.

For example, if you're dealing with transaction processing where consistency and durability are must-have features then you'll be better off with an ACID compliant DB.
On the other hand, social network feeds do not require such a strict compliance so it's acceptable to trade-off ACID in favour of more flexible, easier to scale, approach.


This article does not contain the answer which is better, SQL or NoSQL because as always, it *depends* on your use case.

Having said that, I highly advise *against* following the latest trends blindly and flavour of the month technologies. Instead try to define your use case and make a decision based on your needs.


reach out > relja.jovicevic@gmail.com