teleren/devto huggingface dataset:
Generiere mehr Leads mit automatisierten Call To Action
Tags: wordpress, astra, automatisierung, calltoaction
Published: 2021-04-08 18:02:49

---
title: Generiere mehr Leads mit automatisierten Call To Action
published: true
date: 2021-04-07 14:26:35 UTC
tags: Wordpress,astra,automatisierung,calltoaction
canonical_url: https://j0e.org/call-to-action-automatisieren/
---

![Automatisierte Call to Action](https://j0e.org/wp-content/uploads/2021/04/call-to-action.png)

Wenn es darum geht, Inhalte für deine Website, deinen Blog oder deinen Newsletter zu erstellen, ist es leicht, sich im Meer der Worte zu verlieren.

Sicher, du kannst ein paar tolle Absätze schreiben, vielleicht ein paar Aufzählungspunkte, und es als gut bezeichnen, aber du solltest nicht dabei stehen bleiben. Deine Leser klicken aus einem bestimmten Grund auf deine Inhalte - sie wollen etwas lernen, ein Problem lösen oder ein Ziel erreichen. Wenn du also willst, dass sie weiter lesen, dann erstelle einen Call to Action (CTA).

Ein CTA ist eine einfache Aktion, die dein Leser ausführen kann und die ihm hilft, bis zum Ende zu bleiben.

[Generiere mehr Leads mit automatisierten Call To Action](https://j0e.org/call-to-action-automatisieren/)
No-code Drag-n-Drop 1-page website builder using HTML, CSS, and jQuery
Tags: octoking, website, builder, page
Published: 2021-04-07 14:23:55

#I built OctoKing website builder using HTML, CSS, and jQuery

**About** 🐙👑
OctoKing is 100% FREE and it's a no-code drag-and-drop website building platform. It allows you to create a beautiful and responsive one-page website visually.

**No coding skill required**.

**Build, download, and upload/host the files in your server/hosting**.

App: https://octoking.com/pro/app.html

Templates: https://octoking.com/blog/templates/index.html



**Key Features:**

1. Easy-to-use Drag-n-Drop Website Builder
2. No coding skill required
3. Integrations (MailChimp, Font Awesome Free Icons, Google Fonts, and Google Analytics)
4. PHP Contact form
5. Embed iFrame and Video (Youtube, Vimeo)
6. Pre-design blocks
7. Animation on Scroll
8. Download or Import project file for further modification
9. Add Custom HTML, CSS, and JS codes
10. Unlimited export
Interface Segregation Principle
Tags: isp, solid, interface, interfacesegregationprinciple
Published: 2021-04-07 14:16:22

---
title: Interface Segregation Principle
published: true
description: interface segregation principle
tags: isp, solid, interface, interfacesegregationprinciple
---

# Interface Segregation Principle

The Interface Segregation Principle states that your interfaces should not force the client to implement the methods they don't actually need.

For an example, suppose that you have a `Dinner` (pseudo) class:

```
class Dinner
  meat() { // serve meat }
  veggies() { // serve veggies }
  dessert() { // serve dessert }
```

Later you want to extend it to create Japanese and Vegan foods.

```
class Japanese inherits Dinner
  meat() { ... }
  veggies() { ... }
  dessert() { ... }

class Vegan inherits Dinner
  meat() { // uh oh, no meat here - throw error or noop }
  veggies() { ... }
  dessert() { ... }
```

With the way the `Dinner` class is implemented, it comes with the `meat` method, even though the `Vegan` users will never use it (they will have to implement some sort of `noop` procedure on the `meat` method). Forcing users to use unused methods is not a good practice. It is a violation to the Interface Segregation Principle. 

One way to solve this is to maybe split the parent class:

```
class Meat
  meat() { ... }

class Salad
  veggies() { ... }

class Dessert
  dessert() { ... }
```

Now when you want to create a `Japanese` dinner dish having meat and veggies, you can use them as modules:

```
class Japanese
  include Meat
  include Salad
  include Dessert
```

Now you can just implement a `Vegan` class with only the necessary modules.

```
class Vegan
  include Salad
  include Dessert
```

Using this approach, your dinner classes are loosely coupled. None of the classes are forced to use methods they will never use.
Building cloud native apps: Backing services
Tags: cloudnative, services, managed, heroku
Published: 2021-04-07 14:11:19

## Backing services as attached resources

The Twelve-Factor Apps has a great summary of backing services: https://12factor.net/backing-services. 

I love it and I have very little to add. That's the essence of building a modern software. 

## Off-the-shelf PaaS/SaaS services

I want to make one important point. Wherever possible use integrations to existing PaaS/SaaS managed services rather than trying to build various services yourself. (_Does this ring a bell [Building cloud native apps: Identity and Access Management](https://dev.to/lukaszbudnik/building-cloud-native-apps-identity-and-access-management-1e5m)?_)

The Twelve-Factor App was created by Heroku team and I will use Heroku as an example. I remember when I built my first big app on Heroku back in 2012. I used a number of different Heroku addons (now called [Heroku Elements Marketplace](https://elements.heroku.com/)) and it was a truly mind-blowing experience. I just attached managed services to my app and used them (endpoints and/or API keys exposed via env variables). Heroku was the avant-garde of PaaS.

The beauty of Heroku platform is that you simply can't do it wrong. You don't have access to the underlying infrastructure and there is no temptation for you to host your own Elasticsearch cluster and build your own log management solution. I know: homegrown solutions may appear cheaper, but in terms of the quality can you really match a service delivered by a highly specialized company? 

What many people tend to forget is that your team's time is worth more than the costs of those services. Your team should be focusing on the business value and not trying to figure out how to best implement HA for a database cluster or troubleshoot performance issues with your log management solution.

Just look at [Heroku Elements Marketplace](https://elements.heroku.com/) or check out AWS, Azure, GCP list of managed services. The big cloud players offer you everything you need to develop your application: Compute, Serverless, Networking, Databases, Caches, Queues, Storage, Monitoring, Log Management, Security/Governance & Compliance/Threat Detection & Prevention, Encryption, Machine Learning, Artificial Intelligence, Internet of Things, Mobile, Game Tech, Media Services, VR & AR. AWS offers even crazy services like [AWS Ground Station](https://aws.amazon.com/ground-station/) to control your satellites.

To wrap up:

1. treat backing services as attached resources; 
2. don't build them yourself, use specialized managed services.
Node.js 101 - Events
Tags: javascript, node, beginners, tutorial
Published: 2021-04-07 14:09:35


---
title: Node.js 101 - Events
published: true
description: 
tags: javascript, node, beginner, tutorial
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/4anecy5mdl4pho8w7519.jpg
series: Node.js 101
--- 

<h2>Node.js Events</h2>
Much of the Node.js core is built around an idiomatic asynchronous event-driven architecture in which certain kinds of objects (called "emitters") emit named events that cause Function objects ("listeners") to be called.

The following example shows a simple EventEmitter with a single listener that occur when for example a sale is made 
```js
const EventEmitter = require('events');

const myEmitter = new EventEmitter()

myEmitter.on('newSale', () => {
  console.log('A new sale occur')
})

myEmitter.emit('newSale')
```
The eventEmitter.on() method is used to register listeners, while the eventEmitter.emit() method is used to trigger the event.

<h2>Passing arguments to listeners</h2>
The eventEmitter.emit() method allows an arbitrary set of arguments to be passed to the listener functions

```js
const EventEmitter = require('events');

const myEmitter = new EventEmitter()

myEmitter.on('newSale', (total) => {
  console.log(`A new sale occur total of: ${price}`)
})

myEmitter.emit('newSale', 599.99)
```

<h2>Node.j server work with eventEmitter</h2>
Now that we know about Node.js events. We are able to better understand the logic of the Node.js server object.
```js
const server = http.createServer()

// this will create a event name request
server.on('request', (req, res) => {
  // when Node.js server trigger a request event this message will display
  res.end('Request received')
})

// this will loop and wait for events
server.listen(5000, '127.0.0.1', () => {
  console.log('Waiting for request')
})
```

<h2>Conclusion</h2>
That's it for today. Tomorrow the journey continue. Stay tune!

Follow me on Twitter: <a href="https://twitter.com/justericchapman?ref_src=twsrc%5Etfw" class="twitter-follow-button" data-show-count="false">Follow @justericchapman</a><script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>
Laravel 8 PHP Co-Founder Opportunity
Tags: laravel, php, cofounder, business
Published: 2021-04-07 14:04:14

---
title: Laravel 8 PHP Co-Founder Opportunity
published: true
description: App Uptime - Business Opportunity
tags: laravel, php, cofounder, business
//cover_image: https://direct_url_to_image.jpg
---

I am looking for a technical co-founder to help with a Laravel 8 project I have recently started. 

The service is similar to that of Pingdom, Uptime Robot etc.

- 40% share. 
- Let's do great things together
- Message me for more details.
Not a malware
Tags: go, malware, falsepositive, windows
Published: 2021-04-07 14:01:16

For the past year or so I wrote several Golang based applications for the Windows environment.

The pain of writing software for Windows in non Microsoft tooling is a whole set of posts that I can create, but one thing is worst.

Many applications that are written using Golang are considered to be a Virus, or a maleware of some kind simply because they are written in Go.

When you use tools such as Virus Total, upload a Go based application that you wrote and see how many results of Anti Viruses think that you are trying to create a malware of some kind.

The malware I wrote is just an HTTP server with support of TLS certificate and JWT, registry access for some information, Windows service(ing) to run as one, loading dynamically a .dll file that I wrote (using c++) and few additional COM binding for my witchcraft mix.

That simple mixture was tagged as ransomware just because I had support for x509 inside my code and working as non GUI service.

An "expert" of the organization that the server was suppose to use it told me that I have "hidden code" because of the traces on x509 PKI implementation inside the .exe .

I know, I'm a bad person just because I use tech that can be used for evil.
Like if you use a knife you are an evil person because you can stab or just cut another person - that's why anti viruses consider my code to be a malicious one, right?

After investigation, I realized that I'm not the only one, look at the [Golang FAQ](https://golang.org/doc/faq#virus):

> This is a common occurrence, especially on Windows machines, and is almost always a false positive. Commercial virus scanning programs are often confused by the structure of Go binaries, which they don't see as often as those compiled from other languages.

>If you've just installed the Go distribution and the system reports it is infected, that's certainly a mistake. To be really thorough, you can verify the download by comparing the checksum with those on the downloads page.

>In any case, if you believe the report is in error, please report a bug to the supplier of your virus scanner. Maybe in time virus scanners can learn to understand Go programs. 

If (almost) every program written in Go is considered a malware, what can a simple developer can do?!

I never ever wrote a malware in my life, never tried to do harm, but now if I use a term from my native language: "I need to prove that I do not have a sister" just because someone/thing decided that I do.

So what would you do?
Learnings from Albert Einstein life
Tags: watercooler
Published: 2021-04-07 13:55:22

Einstein a Jewish from Germany was working on Hitler's will at a German university. While at university, he despised the chemical laboratories that were developing weapons of war. He had no idea Hitler would use it to commit mass murders of Jews.


Eddington, an English scientist was the first to explain his theory of gravity  over Newton's gravity laws . English people were not happy as Britain was war with Germany.

*Learning:*
(1) It's not the country but leaders who are right or wrong.
(2) Science has no boundaries. Even learn from your enemies.
(3) Laws can be overturned.

Einstein never wears shocks .
*Learning:* clothes are for your convenience. It is not required that you wear the same clothes as the people around you.

Einstein sleeps for ten hours everyday.
 *Learning* :Sleep as much as you want . You come up with brilliant ideas. In his dream, Einstein examined the theory of relativity.

Einstein smoked a lot of pipe tobacco 
*Learning:* Live life to the fullest

Einstein spends 2-3 hours playing violin.
*Learning:* Music gives you the ability to think.

Einstein eats insects from trees/ plants/ pots.
*Learning:* Consume nutritious foods

Einstein never wanted his brain to be kept in a laboratory after his death. However, the post-mortem doctor took his brain and kept it in his basement for 45+ years for research. He chopped it into pieces before his death. His brain pieces are now on display in a museum.

*Learning:* You don't know what people will do with your body after your death.

Einstein said something in German as last words. Nurses in the United States were unable to understand his final words. As a result, no one knows what Einstein's final words were.

*Learning:* Either die in your country or if in other country use there's language.

_*manish srivastava*_

Anything you want to share?
My first basic API with ASP.NET
Tags: csharp
Published: 2021-03-26 20:21:38

So yesterday was my first day building a web app with ASP.NET. I'm following the course for building an e-commerce app by [Neil Cummings](https://github.com/neilcummings) and jumping straight into an intermediate level. I figured it wouldn't be so hard to follow along since I already have some programming experience. But then again, this is about coming from JavaScript to C#.

### Basic API

The day included only two factors:
-  Make an endpoint that returns a list of products or a specific product by id.
- Setting up a database using SQLite.

Not much, right? However, I  encountered many new concepts and elements that I had to understand before going forward. Some of them were ultimately the same concepts I was familiar with already, just with a different name.

- Kestrel web server
- [Lambda expressions](https://www.tutorialsteacher.com/linq/linq-lambda-expression)
- [Entities](https://stackoverflow.com/questions/2785589/what-is-an-entity-why-is-it-called-entity)
- [Migrations](https://docs.microsoft.com/en-us/aspnet/core/data/ef-mvc/migrations?view=aspnetcore-5.0)

### Objective

The intention behind doing this web app is to get familiar with the  ASP.NET framework and learn all of these new concepts on a practical level. I plan to spend extra time in the first stages and make sure that I understand these basic concepts well enough to get the most out of the course. For that, I have to use documentation and google whenever possible (typical developer).

#### The tools
[NuGet package manager](https://www.nuget.org/) and the different libraries.
[Entity Framework Core](https://docs.microsoft.com/en-us/ef/), which appears to be an important part of developing in ASP.NET.

#### Conclusion
I got to do my first API endpoint. I started touching lightly on the database and migration, but I'm leaving that for tomorrow.

![too much](https://media3.giphy.com/media/THrVdFFbwhwxNPxfGi/giphy.gif?cid=ecf05e47zr5rfyj4kh4k79c2qi6h3kax4abx0f0esp32x9ro&rid=giphy.gif)

It's been overwhelming. It's a lot of new concepts for someone coming from a different language like JavaScript. Everything just feels so different. However, I'm very motivated to continue learning all these awesome tools. So, overwhelming but in a positive way.
React Stack 2021
Tags: react, typescrpt, nextjs, webdev
Published: 2021-04-07 13:37:55

Over the last few years, there have been some big changes in React itself, and the ecosystem has evolved quite a bit too.

Here’s where things stand in 2021.

**React:**
Well isn't that obvious, since we are talking about the React Stack after all. We all know how React has seen a rise in popularity to become one of the most loved front-end frameworks of all time. This also means more developers are building projects in React than ever before.

**TypeScrpt:**
TypeScript is a typed superscript of JavaScript that compiles to plain Javascript, by using React and TypeScript together we get the benefit of statically typed language for the user interface and also lowering the probability of shipping and bugs to the front-end.

**Jest + React Testing Library:**
When it comes to testing I personally prefer Jest with React Testing Library as my go-to packages and they are in fact recommended by the react official documentation. What is great about react-testing-library is that it encourages you to write tests that resemble the way the users would interact with your software this helps you avoid implementation details.

**Redux:**
State management libraries help us to manage the data in our application. The new official Redux Toolkit is excellent and is the recommended approach to use Redux in 2021. If you are going to use Redux, be sure to check those out.
Other alternatives available MobX, Recoil and also using React hooks (useContext + useReducer)

**Chakra UI:**
Chakra UI has an abundance of components and works with the styled system approach which I personally prefer. Another alternative Material UI. Using a component library is a personal choice.

**React Forms:**
Formik and React Hook Form seem to be the favorites right now, with hook-form gaining steam. Both supports schema-based form validation with Yup where you can pass your schema as an optional config. The form will validate your input data against the schema and return with either errors or a valid result. Formik or React Hook For with Yup validation library is definitely a swiss knife for all things related to forms in React.

**Next.js:**
Next Js is a React framework that gives an excellent developer experience with all the features that you would need to build a fantastic application, there is hybrid, static and server-side rendering, Optimized SEO, image caching, TypeScript support, built-in routing, API conventions, and a lot more. It might probably be most if not every React project might be built in the coming years.

Do let me know if I have missed some of them in the comments below.
Thanks for your time reading. Drop a few ❤️ or 🦄 if you like it.
Pipenv, the best way to handle Python Virtual Environments?
Tags: python
Published: 2021-04-07 13:37:03

Virtual environments have always been one of those areas of constant discovery as I've learned python. I've been writing on articles what, how, and why of Virtual Environments and you can find those articles here:

- [Part I: VirtualEnv & Pyenv](https://tuts.alexmercedcoder.com/2021/1/pythonvirtualenv/)
- [Part II: Built-in Virtual Env Generator](https://tuts.alexmercedcoder.com/2021/3/rivisitingpyenv/)

While all of these work great for isolating dependencies and outputting dependencies to a requirements.txt allow use to track dependencies one piece is still missing, deterministic dependency resolution.

When working with NodeJS or Yarn you may notice a .lock file that gets generated when installing libraries, ever wondered what it did? The lock file not only tracks dependencies but also tracks the dependencies of those dependencies so that way if two libraries you use have the underlying dependency that it isn't downloaded multiple times allowing for a faster installation and more consistent reproduction of your environment.

To have this type of feature in Python we will need to use Pipenv to handle our virtual environments! (yep, another venv option, but quite possibly the best one!)

## Setup

First, you got to install pipenv.

```
pip install pipenv
```

## Generating a Virtual Environment

In any folder that you're creating a project for run the following command (similar npm init)

```
pipenv shell
```

This will generate a virtual environment along with the following after you install your first package:

- pipfile: list of dependencies and package info like Package.json for node or Cargo.toml for Rust
- Pipfile.lock: File dependency resolution

** Note if you've created a virtual environment in this directory already it will instead activate it instead of creating a new one.

## Install Libraries

To install libraries your command will look a little different...

```
pipenv install packageName
```

## Learn More

- [Great Article on Pipenv](https://realpython.com/pipenv-guide/)
Perfection is the first step to failure!
Tags: webdev, advice, softwaredevelopment
Published: 2021-04-07 13:31:57

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/amyq8cegvyhmma6bk77h.jpeg)

Developers are by nature very detail-oriented individuals. It's a required trait since the apps we create must meet the requirements imposed on us by both users and the technologies we use.

But, the downside occurs when your attention to detail turns into **_perfectionism_**. Our definition of _perfectionism_ is devoting attention and attention to details associated with a task, **before** they are needed. 

This is where an Agile Methodology can be your best friend.

The Agile Manifesto values "Responding to change over following a plan" and one of the [12 Agile Principles](https://agilemanifesto.org/principles.html) is:

> Welcome changing requirements, even late in development. Agile processes harness change for the customer's competitive advantage.

Timing is critical since it's important to **_do the right thing at the right time_**. Some practical tips include:

- Create simple app components based on what you currently know and add to them as new details surface in later sprints.
<br/>

- Don't let what you've already created lead to resistance to change. Your code is the means to a goal, **not** the goal itself.
<br/>

- Design and write your code assuming that it will need to be modified and enhanced.
<br/>

- Treat your backlog as a "living" document. Continuously groom it in each sprint as new details are found.
<br/>

- Don't hide your status from the team. Information should be freely and openly shared (including problems!) since all teammates are equally responsible for reaching the MVP.

Keep in mind that being an Agile Developer means you embrace the concept of incremental development. Start simple and add complexity as needed!

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/fqi9frqci2jmemegd8j2.gif)

### Before you Go!

> _Chingu helps you to get out of “Tutorial Purgatory” by transforming what you’ve learned into experience. The experience to boost your Developer career and help you get jobs._

> _You can learn more about_ **_Chingu_** _& how to join us at_ [_https://chingu.io_](https://chingu.io/)

* * *