teleren/devto huggingface dataset:
Disable SSL Verifications in Proxy and Azure Node
Tags: programming, blog, ssl, node
Published: 2023-02-12 22:53:17

For Proxy Node https://steemyy.com/node/ and Azure Load Balance Node: https://justyy.azurewebsites.net/api/steem the SSL verification has been disabled:

```js
const https = require('https');
const httpsAgent = new https.Agent({
    rejectUnauthorized: false,
});
```

And the [fetch API](https://helloacm.com/javascript-nodejs-function-to-check-the-plugins-on-steem-blockchain-rpc-nodes/) can be set to use the above custom agent:

```js
await fetch(URL, {
    method: "POST",
    headers: {
        "Content-Type": "application/json"
    },
    agent: httpsAgent,
    body: body,
});
```

Adding two more candidate RPC nodes (@upvu https://api.upvu.org and @jrcornel.wit https://steem.techs.exchange):

```json
{
  "__serverless_version__": "2023-02-12",
  "__steem_servers__": [
    "https://api.campingclub.me",
    "https://api.steemwow.com",
    "https://steemapi.3dkrender.com",
    "https://api.steem-fanbase.com",
    "https://api.blokfield.io",
    "https://api.upvu.org",
    "https://api.steemit.com",
    "https://api.justyy.com",
    "https://api.steemzzang.com",
    "https://api.pennsif.net",
    "https://steem.techs.exchange",
    "https://api.dlike.io",
    "https://steemapi.boylikegirl.club",
    "https://api.wherein.io",
    "https://api.steememory.com"
  ]
}
```

Also, added to [Node Status Tool](https://steemyy.com/overview.php)


<hr/>
<img src="https://justyy.com/png/whale.png" />

### [Steem](https://steemyy.com) to the Moon!
You can swap the STEEM/SBD to USDT (TRC-20) via [Steem2USDT](https://steemyy.com/steem2usdt.php)
CORS: Cross-Origin Resource Sharing
Tags: cors, webdev
Published: 2023-02-12 22:40:54

Have you ever come across CORS errors while you're developing web sites and web applications? If yes, I feel you. You're not alone. And if you haven't yet, you may get them in the future.

So in this article, I will explain what CORS(Cross-Origin Resource Sharing) is, what causes this problem, and hopefully how to fix the issues.

## What is Same-Origin Policy?
Same-Origin Policy, also known as SOP, prohibits scripts or documents loaded from one origin from connecting to resources from another origin for web security reasons.


> A quick reminder of what an origin is!
An origin is defined by scheme, hostname, and port of the URL, which means that they are the same origin when sharing the same scheme, hostname, and port.


Assume you visit a website whilst you're logged into some social media account, a single JavaScript file on that website could do tons of things, such as enabling it to access your private messages. In short, Same-Origin Policy was developed in order to prevent such attacks and to protect your information.

## What was SOP's issue?
Despite the importance of Same-Origin Policy I mentioned above, people needed to find new technologies as AJAX started to be developed and spread throughout the world so that we can call APIs from different origins. To straight to the point, this is where Cross-Origin Resource Sharing comes into picture.

## CORS
Space Frontier Game
Published: 2023-02-12 22:14:18

## ABOUT THE GAME

Space Frontier is a game about building a thriving sci-fi settlement. 

The main goal of the player is to create a robust infrastructure, which would allow the settlement to thrive and ultimately reward the player. 

This is done by forming strong relations with NPCs (role-playing aspect) and maintain and manage the city layout (city builder aspect).



![City Building View](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/lgj98ei6ixgn62czleho.jpeg)


![Dialog view](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ly7kd6vfesuhr07jjspw.jpeg)

## Inspirations
The idea came from a mix of old-school 'sierra' city builders and 90-00's RPGs (like fallout2 and NVN). 

The core loop could be defined by the following statements:
1. collect daily rewards from the buildings.
2. hire agents.
3. wait for them to offer help (this happens over time, in a form of a quest/dialogue)
4. use these agents+rewards to fix deteriorated buildings and create new ones.

The very basic version of it is implemented in current version, but there are tons of ideas that didn't make it yet.. e.g.

- not only fix but improve builings.
- have your agents progress (every job done gives XP, essentially making them more efficient and 'unlocking' better quests). Since Agents are NFTs this essentially means upgrading the tokens.
- symbiotic placement - correctly placed buildings in proximity creates a positive (or negative) effect on daily reward yield.

The above can be considered as my personal roadmap :)

##Tech
Obviously the client is WebGL Unity app, that uses ThirdWeb gaming SDK.

The backend is a node express app, with a combination of off-chain and on-chain data.

Off-chain:
- In order to not make the client to sign every transaction, the **game balance** is currently stored off-chain. This balance can be withdrawn to your wallet.

- **Quest allocation** is also calculated, assigned and stored off-chain. 

- **Reward calculation** is calculated and assigned offchain.

On-chain:

- The main on-chain integration is NPC's. You buy the NFTs in-game, and they appear in your city as NPC's that are linked to the quests that are generated over time.

Important note:
Given the turn based nature of the game, it was designed with having most of it on chain. This means:
- every turn is a transaction signed by the user.
- quest allocation and taxation are contracts that are executed through a cross contract call, within 'turn' the transaction.
- game balance is managed by custodial wallets, (allowing to seamlessly use it, without signing a tx every time you want to do something, but leveraging the security of blockchain).

Once again, this is the likely roadmap for the tech part!


## TEAM
I'm a game developer with embarrassingly big number of years of professional experience in the field. Have been involved in a multitude projects with massive user base. Recently I started to be heavily involved with blockchain with a multitude of tech, both EVM and WASM.
On Ideology
Tags: elm
Published: 2023-02-12 22:06:08

Programming languages all implicity include an ideology - a set of core ideas and philosophies - that serve as a sort of conceptual framework for the choices that are made when one is using a given langauge to create a piece of software.

An absence of a clearly-defined ideology is still an ideology; in that case, the ideology is, "anything goes". We have seen how this sort of ideology has worked out, over time and at scale; no examples need to be given. Ultimately, in a language community and ecosystem with no clearly-defined ideology, contributors tend to add their own ideas about "how things could work well" and create frameworks, tooling, scaffolding; in doing so, they are creating an ideology.

For some programming language communities, the tools are an intentional byproduct of an ideology refined and followed to its logical conclusions. This is not always the case - and whether or not it is the case is certainly not some sort of value judgment. Some languages exist as an intersection of "what it was possible to do with computers at the time" and "what seemed most ergonomic, given the constraints".

Elm is most certainly _not_ a member of the latter set. In my experience, and as evidenced most recently by the latest round of handwaving-freakoutery on the orange website[^1], this results in surprise and dismay for those unaccustomed to confronting a programming language's ideology head-on; as much as again, when it is contra to their own ideals.

The Elm ecosystem's design decisions - notoriously, the decision to disallow kernel code in 0.19 - function as a set of constraints to enforce the author's ideology on the system as a whole. Many have voiced an opinion that this was not only "wrong" - as in, "not technically correct", but also "wrong", as in "immoral".

Some of Elm's promises and guarantees are literally impossible to realize without this sort of constraint. Should people, such as the author of Elm, be _explicity discouraged_ from creating these constraints, simply because "that's what the people and community want"?

Was it morally wrong for the author of Elm to remove that functionality? Put another way: was there a moral imperative for him to continue to support a feature set that went against his ideology?

What is the moral weight of public opinion?

Is there ever a moral imperative for an Open Source engineer to "listen to the community", regardless of whether or not doing so goes against their personal convictions for how the thing that they've made should function?

There are some types of systems that can only exist in a certain form when they are the product of one, or few minds. Should those systems not be permitted to exist?

What do you value?

[^1]: https://news.ycombinator.com/item?id=34746161
Why Microservices are more complex than you think ?
Tags: microservices, webdev, programming, tutorial
Published: 2023-02-12 21:57:19

Microservices are a distributed system architecture, and they have lots of problems associated with them. Nowadays, more and more companies claim they are using microservices, whereas the reality is quite different from what they claim.

The defining characteristics of microservices are

1. They are small.
2. Focused on One Task
3. Aligned with a bound context
4. Autonomous
5. Independently deployable
6. Losely coupled

## They are small.
Early pioneers of microservices used to respond to the question by saying that 
> An ideal microservice fits inside James Lewis' head.
James Lewis was the one who popularised the idea of microservices. The rationale behind that was to compartmentalise a problem.

### How to measure if the given microservice is actually micro

If you can recode the microservice in a week or two, I think you are on the right path. That's one of the ways to measure if you are on the right scale.


## Focused on One Task
To segregate a monolithic architecture, we must first determine which sub-problems our microservices should be divided into.Each microservice aims to achieve one task when viewed from the outside.


## Aligned with a bounded context

This idea comes from the book **Domain-Driven Design**, written by **Eric Evans**. As per Eric, "bounded context" can be defined as 

> A defined part of software where particular terms, definitions, and rules apply in a consistent way.

This means that if we fail to segregate our services well, breaking our application into microservices could actually backfire as it will make services tightly coupled.

## Autonomy

The team handling each microservice should be autonomous in changing the implementation. The true value of microservices is that the autonomy and lack of coordination they provide enable organisations to scale quickly.

## Deployable on its own

Since microservices give the team options to deploy without being constrained by other teams, it makes their progress more significant.

Now the problem arises: if you always test your service with others before release, it is not independently deployable.

The real value that microservices bring to the table is that they can be built, tested, and deployed independently.

So, in short, one can say, 

> Microservices are an organization's decoupling strategy.


## Losely Coupled
The interface to a microservice is a public API. Therefore, it should be changed with great care. If you keep changing the API too often, this defeats the whole purpose of the microservices architecture. Also, when consuming an API, use the minimum data that you can to reduce coupling.
Four more tools you can't live without
Tags: webdev, management, vscode, automation
Published: 2023-02-12 21:47:58

Since the last post in November was such a success and reached almost 500 views in less than four days and 58 followers in less then a week, I couldn't resist writing another article. This is “four more tools you can’t live without” with even cooler tech for your daily coding sessions.

---

**1. Space Field (Vscode Theme)**
Space Field is a Vscode Theme inspired by Sebastián Veggiani’s (Field Lights). and with its minimalistic and dark colors I believe it to be a good and viable choice for any developer. On the other hand it uses syntax highlighting for components working with any framework out there, giving you even more visual confirmation of your html.

![screenshot](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/nv6ixvpzykookd88vk9n.png)



If you like what you see, I would appreciate a star on Github. 
https://www.seechris.app/work/spacefield

---

**2. asdf (Package Manager)**
If you use multiple versions of a CLI tool e.g Node. asdf can manage multiple runtime versions of over 500 different CLI’s including Node, git and ruby. This makes a huge difference when working on projects with different configurations and other devs.


![Screenshot](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/87p8f5q2pgdbaplxiw3t.png)



https://asdf-vm.com/ 


If you decide to use asdf, install it through git as follows. 

```
git clone https://github.com/asdf-vm/asdf.git ~/.asdf --branch v0.11.1
```

And if you're using ZSH as your primary Shell, paste 

```
. "$HOME/.asdf/asdf.sh" inside your ~/.zshrc file
```
 for it to work and run the proper path. further installations of plugins can be found [here](https://asdf-vm.com/guide/getting-started.html#_4-install-a-plugin).

And if nothing of what I just explained made any sense, here's a [video](https://www.youtube.com/watch?v=RTaqWRj-6Lg&ab_channel=sontek) explaining how it works :)

---

**3. Wappalyzer (Tech Inspector)**
The best and personally a tool I've used regularly since I learned of it. It helps identify what stack a specific web app is using and even what version at times. I don't believe it's going to change the way we view web apps today, but it will help with insights, a tool I can’t recommend enough.
https://www.wappalyzer.com/


![Screenshot](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/kmk8zv8bdc7tplvrk6aa.png)



---

**4. Jenkins (Automation)**
Automating tasks is always so much more satisfying, and in the end probably saves a lot of time. Jenkins can build, test and deploy code with a self hosted server. And I can honestly say it's pretty cool. They ensure it works with any setup or deployment method e.g Docker, Node or Gradle. Making it the leading open source automation tool.
https://www.jenkins.io/


![Screenshot](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/y2u7ko9i274e2s41r9cj.png)

---

And this is it.
I hope you can use any of the tools mentioned in this article, and until next time.
 
XOXO Tech Lover.
How Cohorts Work in CodingDojo
Published: 2023-02-12 21:46:07

One of the greatest benefits of Coding Dojo is the opportunity to work with other individuals who are also learning software engineering. Your cohorts are a valuable resource and can provide support and collaboration as you work on projects together. Leaning on your cohorts for support and collaboration can help you overcome challenges and expand your knowledge and skills. 

Leaning on your cohorts and focusing on learning as the goal, instead of just trying to finish a project the "right way," can provide many benefits. You'll have the opportunity to collaborate and gain support from your peers, grow as a software engineer, experiment and take risks, develop your problem-solving skills, and gain real-world experience. Embrace the learning process and focus on growing, not just getting things "right." 

Working with others who have more experience can be incredibly valuable. They can provide insight and guidance into best practices, help you understand complex concepts, and give you new perspectives on software engineering problems. Additionally, by working with those who are more experienced, you can learn from their mistakes and avoid making the same mistakes yourself.

On the other hand, teaching and mentoring those who are less experienced can be just as valuable. By explaining difficult concepts and helping others overcome challenges, you'll reinforce your own understanding and knowledge. Additionally, helping others can foster a sense of community and collaboration, and you'll feel a sense of pride and accomplishment in your role as a mentor.

In Coding Dojo, the focus should be on learning and personal growth, and collaborating with others who have different levels of experience can provide many opportunities for growth. By learning from those who know more, and teaching and mentoring those who know less, you'll become a well-rounded software engineer with a deep understanding of the concepts and a diverse range of skills and experiences. Remember, the goal is to grow, not just to finish projects the "right way." Embrace the learning process and don't be afraid to take risks and make mistakes. You'll be surprised at how much you can learn and grow when you focus on learning and collaborate with others.
CodingDojo
Tags: bootcamp, programming
Published: 2023-02-12 21:37:53

Coding Dojo is a comprehensive program designed to help individuals learn and master software engineering skills. This program provides an intensive, hands-on learning experience that can help individuals jumpstart their careers in technology. In this blog post, we'll explore what Coding Dojo is, how it works, and why it's so effective for individuals who want to learn software engineering.

### What is Coding Dojo?
Coding Dojo is a structured, immersive learning program that focuses on teaching software engineering skills. The program is designed to help individuals build a strong foundation in software development, with a focus on full-stack web development. The program covers a range of topics, including front-end development, back-end development, databases, and deployment.

### How does Coding Dojo work?
Coding Dojo is an intensive, full-time program that runs for 14 weeks. During this time, individuals attend classes for up to 6 hours a day, 5 days a week. The program is highly structured, with a focus on hands-on learning. Participants work on a variety of projects, both individually and in teams, to gain practical experience and build their skills.

### Why is Coding Dojo effective?
Coding Dojo is effective for several reasons. Firstly, the program provides a structured, intensive learning experience that allows individuals to focus solely on software engineering. The full-time, hands-on approach to learning ensures that individuals are constantly working on real-world projects, gaining practical experience and building their skills.

Secondly, Coding Dojo provides a supportive, collaborative learning environment. Participants work in teams, allowing them to collaborate with others and learn from each other. This helps to build a sense of community and encourages participants to support one another as they work towards their goals.

Finally, Coding Dojo offers a comprehensive curriculum that covers a range of topics, including front-end development, back-end development, databases, and deployment. This allows individuals to build a strong foundation in software engineering, and helps prepare them for a career in the technology industry.

In conclusion, Coding Dojo is an effective program for individuals who want to learn software engineering. The structured, hands-on approach to learning, supportive environment, and comprehensive curriculum make Coding Dojo an ideal program for anyone who is looking to jumpstart their career in technology. Whether you're a beginner or an experienced professional, Coding Dojo can help you build your skills and achieve your goals.
Mentoring in Software Engineering
Tags: mentoring, programming, beginners
Published: 2023-02-12 21:35:39

Mentoring is an important aspect of the learning process, especially in software engineering where the field is constantly evolving and new technologies are emerging. Mentoring provides a unique opportunity for individuals to learn from experienced professionals and gain valuable insights into the industry. In this blog post, we will discuss why mentoring is so important for those who are learning software engineering.

- Personalized Guidance:
Mentoring provides personalized guidance that is tailored to the individual’s learning style, pace, and career goals. A mentor can help identify areas of strength and weakness, and provide guidance on how to improve and grow. With their years of experience and expertise, a mentor can provide valuable advice on how to navigate through the challenges of the software engineering field.

- Networking Opportunities:
Mentoring relationships can also provide opportunities for networking. Mentors can introduce their mentees to others in the industry and provide opportunities for them to attend events, meet other professionals, and make connections that can be beneficial in their future careers.

- Learning from Experience:
Mentors bring years of experience and knowledge to the table. They have already faced many of the challenges that new software engineers will encounter, and they can provide valuable insights into how to overcome these challenges. Mentors can also share their own experiences, both positive and negative, to help mentees avoid making the same mistakes.

- Access to New Opportunities:
Mentors can also provide access to new opportunities for their mentees. For example, a mentor may be able to recommend their mentee for a job, introduce them to a new project, or provide them with exposure to new technologies.

- Improving Technical Skills:
Mentoring can help individuals improve their technical skills. A mentor can provide guidance on how to develop new skills, work on challenging problems, and learn new technologies. They can also provide feedback on projects and help mentees identify areas where they can improve.

Mentoring is an invaluable resource for individuals who are learning software engineering. It provides personalized guidance, networking opportunities, learning from experience, access to new opportunities, and helps improve technical skills. If you're looking to grow your skills and advance in your career as a software engineer, consider seeking out a mentor who can help guide you on your journey.
schema-org-java 0.4.0 released - Java library for working with Schema.org data in JSON-LD format
Tags: java, programming, maven, seo
Published: 2023-02-12 21:32:27

If you've ever worked with structured data, you're probably familiar with [Schema.org](http://schema.org).

And you must have realized that entities contain a lot of information and that inheritance can be complex.

So it can be tedious to create all the entities needed for your project and then serialize / deserialize the data in [JSON-LD](https://json-ld.org/) format.


[schema-org-java](https://github.com/Kobee1203/schema-org-java) is a library to work with Schema.org entities.

The entities can be easily generated with the Maven plugin, and can then be serialized / deserialized to JSON-LD format with the serializer module.

The library has the following features:
- Fully supports the vocabulary defined in the http://schema.org namespace.
- Fully supports type multiple inheritance, multiple values per property in http://schema.org.
- Every Schema.org type has a corresponding Java interface which provides convenient getter/setter methods for getting/setting the values of the properties of that particular type.
- Supports the generation of all Schema.org types at once, or specific ones.
- Fully supports Schema.org documentation of types and properties by adding Javadoc on generated classes and methods.
- Supports different versions of the Schema.org vocabulary.
- Supports serializing and deserializing Schema.org objects to and from JSON-LD formats.

Here is a video illustrating the generation and creation of Schema.org entities:
{% embed https://user-images.githubusercontent.com/1423193/218336603-4cb1bc82-0daa-4187-9c34-72e206bccfe9.mp4 %}

If you are interested, please take a look and give me your feedback :)