teleren/devto huggingface dataset:
What is SSRS with Power BI?
Tags: writing, beginners
Published: 2023-07-03 06:14:09

SSRS (SQL Server Reporting Services) and Power BI are two separate Microsoft technologies used for reporting and data visualization. While they have some similarities, they serve different purposes within the realm of business intelligence and reporting.

SSRS, or SQL Server Reporting Services, is a server-based reporting platform that allows you to create, manage, and deliver various types of reports. It is part of the Microsoft SQL Server suite of tools and primarily focuses on traditional paginated reports. These reports are typically formatted and designed for printing or viewing in PDF or Excel formats. SSRS provides a wide range of features for designing and publishing reports, including data source connections, data transformations, report layout design, and report scheduling and distribution.

By obtaining [Power BI Certification](https://www.edureka.co/power-bi-certification-training), you can advance your career in Power BI. With this course, you can demonstrate your expertise in Power BI Desktop, Architecture, DAX, Service, Mobile Apps, Reports, many more fundamental concepts, and many more critical concepts among others.

On the other hand, Power BI is a business analytics service provided by Microsoft that enables users to create interactive and visually appealing reports and dashboards. Power BI focuses on self-service business intelligence and data visualization. It offers a more modern and interactive approach to reporting, allowing users to explore and analyze data in real-time, create interactive dashboards, and share insights with others. Power BI supports various data sources, including databases, cloud services, and on-premises data, and provides advanced data modeling capabilities.

While SSRS and Power BI are distinct tools, Microsoft has introduced integration between them to leverage the strengths of both platforms. With Power BI Report Server, you can publish Power BI reports to an on-premises report server, which combines the modern visualization capabilities of Power BI with the on-premises deployment and security features of SSRS. This integration allows organizations to use Power BI for interactive analysis and reporting while maintaining their data on-premises.

It's worth noting that Microsoft is continuously evolving its reporting and analytics tools, and the specific capabilities and integrations between SSRS and Power BI may change over time. It's advisable to refer to the official Microsoft documentation and resources for the most up-to-date information on these technologies and their integration.
Reinventing Pod6: Moving Forward
Tags: pod6, podlite, rakulang, documentation
Published: 2023-07-02 17:08:19


Today is a great day because I feel that some interesting changes are happening in an important aspect of my work.

Recently, I've become involved in the process of working on a new specification for the Pod6 markup language. Documentation is a crucial part of any programming language, and despite that, Pod6 has remained unchanged for quite a while. So, the fact that the relevance of Pod is being addressed and taking a step forward is truly commendable. I want to extend my sincere appreciation to you, Richard (@finanalyst), for this.

As I started reviewing early version of Rakudoc, which Richard sent to me, I realized that I have a wealth of ideas and experience with Pod6 that I've been preparing for this moment. They are needs to be organized, put into the text, and shared. It would also be beneficial to review ideas, previous work, revisit all the discussions that have taken place in the Raku/Doc community, which will require some time.

So, I've informed Richard that I'll be preparing my version of specification of the "_next Pod_". 

I estimate that this process will take around 3 weeks. Maybe a little bit less, or more.

I believe that considering multiple viewpoints will be highly beneficial, especially at this early stage.

To keep things focused and avoid any unintended consequences due to my own oversight, I've decided to work on this project in a quiet mode and will share a diary of my progress once the work is completed.

In addition to my work on the new Pod6 specification, I've also decided to take a pause on working on the next release of [Podlite editor](https://github.com/podlite/podlite-desktop). 


Thank you for your attention!

With best,
Alex
Top 10 Essential Git Commands for Beginners (Version Control)
Tags: webdev, javascript, programming, tutorial
Published: 2023-07-03 05:57:03

> In the world of software development, effective version control is crucial for collab...

[
![Git Commands](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/z9su6pxrellbh7hvnsea.png)](https://www.webdeveloperblogs.com/2023/06/top-10-essential-git-commands-for.html)
What is Regenerate responses in ChatGPT?
Tags: chatgpt
Published: 2023-07-03 05:31:43

"Regenerate responses" in ChatGPT refers to the process of generating new or fresh responses from the language model. It involves making additional requests to the model to obtain different answers or outputs for a given input prompt or conversation.

In interactive conversations with ChatGPT, users typically provide a message or a series of messages as input, and the model generates a response based on that input. However, if you're not satisfied with the initial response or want to explore different possibilities, you can choose to regenerate the response by sending a new request to the model with the same or modified input.

Regenerating responses can be useful in several scenarios. For example, it can help in refining the output by asking the model to provide more details or clarify certain points. It can also be employed to explore alternative perspectives or generate diverse responses by slightly modifying the input or changing the phrasing of the questions.

When regenerating responses, it's important to keep in mind that the model's responses are generated based on the context provided in the conversation history. So, if you make changes to the input messages, it may affect the subsequent responses. Additionally, regenerating responses may not always guarantee consistent answers, as language models have a degree of inherent randomness and can produce different outputs for the same input.

Regenerating responses can be done by sending additional requests to the ChatGPT API or by using the corresponding SDKs or libraries provided by OpenAI, depending on the platform or integration you're using. By obtaining [ChatGPT Training](https://www.edureka.co/openai-chatgpt-training-course), you can advance your career in ChatGPT. With this course, you can demonstrate your expertise in GPT models, pre-processing, fine-tuning, and working with OpenAI and the ChatGPT API, many more fundamental concepts, and many more critical concepts among others.

It's worth noting that OpenAI has certain guidelines and best practices regarding the use of regenerating responses, such as avoiding excessive or unnecessary calls to the API and considering the associated costs and rate limits. These guidelines help ensure efficient and responsible use of the technology.

I hope this clarifies the concept of regenerating responses in ChatGPT. If you have any further questions, feel free to ask!
Introduction to Apache AGE: Exploring the Capabilities
Tags: postgres, database, apache, graphs
Published: 2023-07-03 04:16:12

In today's data-driven world, businesses and organisations are faced with the challenge of managing complex and interconnected data. Traditional relational databases often struggle to efficiently handle relationships and connections between data points. This is where graph databases come into play, providing a powerful solution for representing and analysing highly connected data. 

One such graph database is Apache AGE (Apache Graph Extension), a cutting-edge open-source project that brings graph database capabilities to the PostgreSQL ecosystem. In this blog post, we will delve into the world of Apache AGE, exploring its key features, benefits, and use cases.

## Integration with PostgreSQL:
Its simple interaction with current PostgreSQL infrastructure and tooling is one of Apache AGE's key features. Utilising their knowledge with PostgreSQL, organisations that already use PostgreSQL may quickly integrate Apache AGE into their current systems.

## Scalability & Flexibility:
Any database system must have scalability and dependability, and Apache AGE meets these needs. It offers horizontal scalability, enabling enterprises to successfully manage increasing data volumes. For handling networked data, PostgreSQL and Apache AGE together provide a solid and dependable base.

Apache AGE's flexibility and extensibility are also among its many advantages. Users may combine the strength of relational and graph databases by combining SQL and graph queries, enabling a variety of use cases and offering flexibility in data modelling and analysis.

## Use Cases:
There are numerous domains and use situations where Apache AGE is used. It can assist in finding important connections and producing individualised recommendations, for instance, in social networks and recommendation systems. The graph features of Apache AGE help to spot trends and abnormalities in fraud detection and cybersecurity. Additionally, it can be utilised for network analysis, semantic data management, and supply chain optimisation.

## Community:
The Apache AGE community is active and helpful, providing tools, documentation, and development that is driven by the community. The ecosystem is improved through integration with other tools and frameworks, which also gives consumers access to more possibilities.

## Conclusion:
Apache AGE is a powerful graph database solution that integrates seamlessly with PostgreSQL. Its native graph support, flexibility, performance optimisations, and integration with existing PostgreSQL infrastructure make it an attractive choice for managing highly connected data. With Apache AGE, businesses can unlock valuable insights and leverage the power of graph databases in a familiar and scalable environment.
How to use useState()
Tags: react, beginners
Published: 2023-07-03 04:03:33

React's useState hook is an essential tool for managing state within functional components. This hook lets you add a state variable to your component to allow stateful behavior and update components in response to events or user interactions.

## Usage of useState
To start using useState, import it from the 'react' package at the top level of your component.

`import { useState } from 'react';`

Next, declare a state variable with array destructuring. The naming convention for state variables is [something, setSomething]. 

`const [age, setAge] = useState(24);`

useState returns an array with two items: 
1. The current state, initially set to the initial state you provided. 24 in the example above.
2. The set function that lets you change the current state to another value in response to a user interaction or other event.

Call the set function with some next state to change the current state. 

`setAge(21);`

## Updating State Based on Previous State
To update state based on the previous state, pass an updater function instead of the next state. The set function only affects what useState will return starting from the next render; it does not change the state in the already running code.
```
function handleAgeClick() {
  setAge(age + 1); // setAge(24 + 1)
  setAge(age + 1); // setAge(24 + 1)
  setAge(age + 1); // setAge(24 + 1)
}
```
Each setAge(age + 1) call becomes setAge(24 + 1). Fix this by using an updater function.

```
function handleAgeClick() {
  setAge(a => a + 1); // setAge(24 => 25)
  setAge(a => a + 1); // setAge(25 => 26)
  setAge(a => a + 1); // setAge(26 => 27)
}
```
The updater function takes the pending state and calculates the next state from it. I named the pending state argument 'a' which is the first letter of the state variable 'age'. This is a common naming convention you can follow.

## Avoid Recreating the Initial State

```
function CustomerOrders() {
  const [orders, setOrders] = useState(createInitialOrders());
}
```

If you invoke a function as your initial state, the result will only be used for the initial render but the function will be called on every render. This can be wasteful but can be solved by passing the function as an initializer function to useState instead.

```
function CustomerOrders() {
  const [orders, setOrders] = useState(createInitialOrders);
}
```
React only calls your initializer function during initialization and not on every render.

## Objects and Arrays in State
You should not mutate your existing objects since, in React, state is read-only.

`form.lastName = 'Smith';`

Rather than mutate your objects, replace the whole object and create a new one with the spread operator.

```
setForm({
  ...form,
  lastName: 'Smith'
});
```

## Conclusion
By understanding and effectively utilizing useState, you can enhance the functionality and interactivity of your React components, making your applications more dynamic and responsive. To learn more about useState and everything React, please take a look at the [React reference](https://react.dev/reference/react) pages.
Solve: Ubuntu 20.04 booting to a black screen with login
Tags: ubuntu, terminal
Published: 2023-07-03 03:54:24

Hello there dear reader.
As a Linux user, you've probably encountered alot of bugs while using the system. Some are minor bugs that take only a few seconds or hours to fix, but nothing ever prepares you for the moment where your PC boots into a black screen of death.

![tty screen](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/4u3hz9oetv481uhgi98d.jpg)

That has to be one of the worst moments in the life of a developer. You have no UI to use. When you start your PC, you are in a huge terminal with no user interface. You literally have to learn how to configure your PC.

![linux meme](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/xtiwds53e5j8mkd4cmpr.jpeg)

But worry no more, I have once faced this bug and in this article, I'm going to explain how to solve(how I solved) this error.
When I got the error, every time I tried to boot my machine, I got the following output:
```
Ubuntu 20.0.4 LTS <my_username>- pc tty1
<my_username>-pc login:
```
The output above is a TTY(teletypewriter). A TTY, or teletypewriter, is a subsystem in Linux and Unix that manages the interaction between the kernel and user space. It does this by providing a set of drivers that allow the kernel to communicate with physical and virtual terminals.
These drivers are responsible for handling the input and output of data, as well as providing support for features such as line editing and session management.In other words, TTY is the foundation on which all user interaction with Linux and Unix is built.
If you want to learn more about teletypewriter, read more on this article: [The TTY Demystified](https://www.linusakesson.net/programming/tty/index.php?ref=itsfoss.com).



To solve this, follow these steps:
 1. Log into tty with your username and password:

```
Ubuntu 20.0.4 LTS <my_username>- pc tty1
<my_username>-pc login: <my_username>

<my_username>-pc $user: <your password>
```

2. Try unsistalling the ubuntu-desktop package by typing:

```
sudo apt remove ubuntu-desktop
```
3. If your PC does not have the *ubuntu-desktop* package installed, the terminal will return:

```
package not found
```

4. If the package is missing, you can try re-installing the package by running:
```
sudo apt install ubuntu-desktop
```
This process might take a while. After the installation is complete, restart your PC and your desktop application will automatically load.

I hope this article helps. If you like the article, please leave a like and feel free to leave any concerns on the comment section.That is all for today.
Using bootstrap in react
Tags: react, bootstrap, javascript
Published: 2023-07-03 03:31:31

In the modern project, we will use react framework to build a website. sometime we create our own CSS to decorate web page. However, it maybe a little bit complicate for developers since painting design is difference from code design. Thus, bootstrap is good tool to help us improve our web design. For instants, when we import **Navlink ** from react-route-dom, we can apply bootstrap's classnames into NavLink components. 

```
<NavLink className="navbar-brand fs-3" to="/" exact>Supper Pizza</NavLink>
```
this bootstrap css will be used in the nav bar and save your time to  design each element. 
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/4nvujivzepdwrthcy67k.jpg)
As you see, the **Nav ** bar is looks pretty well, and we can use more time focus on front-end and back-end code design.
AntDB Overall Product Architecture
Published: 2023-07-03 03:25:35

AntDB adopts cloud-native distributed architecture with independent intellectual property rights and realizes online elastic scaling and ACID features of distributed transaction; it is 100% compatible with MySQL protocol and supports SQL2016 standard; meanwhile, it realizes the ultimate performance on ordinary PC server cluster. It features financial-grade data strong consistency, high availability, high performance, smooth scaling, support for SQL2016 standard, and intelligent visual operation and maintenance.

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

optimized driver layer with link redirection capability, responsible for linking to the entire cluster

management node, also a Raft cluster, guarantees high availability of the management node through multiple copies, which is responsible for the data distribution strategy of the cluster and the pressure load of each node

data slice (Raft Group), which can be configured with multiple copies within the data slice, with Raft protocol to ensure high availability and strong consistency between copies

service nodes, Active-Active architecture, including independent SQL engine.

Intra-cluster RDMA interconnection
AntDB Product Functional Architecture
Published: 2023-07-03 03:22:49

AntDB, shown in Figure 5-1, consists of five components, namely drivers for various development languages, SQL processing layer, distributed executor, storage engine, and management and tools.

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

Driver: the application programming interface between the database and various development languages, which establishes a channel of communication between the application and the database

SQL processing: responsible for SQL parsing, optimization and execution

Distributed executor:  provides data routing, remote data access, distributed transaction control, etc.

Storage engine: a module of the database management system, which provides CRUD operation functions for single table data as well as transaction management functions

Management and tools: the ecosystem of the database
Test SOAP Web Service using Postman tool
Tags: api, soap, postman, tutorial
Published: 2023-07-03 03:07:44

We can use [Postman tool](https://www.postman.com/) to even make call to SOAP based web services, something that I was not aware of (always used SOAP UI tool). So, thought of putting together steps that can be followed to test SOAP web services using Postman tool. Here are the steps:

**1. Install Postman:** If you haven't already, download and install Postman from the [official website](https://www.postman.com/downloads/).

**2. Import WSDL:** Obtain the WSDL (Web Services Description Language) file of the SOAP web service you want to test out. The WSDL file describes the available SOAP operations and its input/output parameters. 
In Postman, go to `"File" -> "Import" -> "Import From Link" and enter the URL of the WSDL file Or provide path of file from local filesystem`. Postman will generate a collection based on the WSDL.

Sample WSDL link - http://www.dneonline.com/calculator.asmx?wsdl

**3. Create a Request:** Once the collection is imported, you'll see a list of available SOAP operations as requests in Postman. Select the request you want to execute.

**4. Modify Request Parameters:** Inspect the request details, including headers, request body, and parameters. Update the necessary values to match your specific use case. For SOAP requests, the body will typically contain XML-based SOAP envelopes.

**5. Send the Request:** Click on the "Send" button to execute the SOAP request. Postman will make the HTTP request to the SOAP web service endpoint specified in the WSDL. The response will be displayed in the Postman interface.

**6. Verify the Response:** Analyze the response returned by the SOAP web service. Postman provides various views, such as raw, pretty, and preview, to help you interpret the response XML or JSON data. You can open console to view the request and response packets.

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

By following above steps, you can use Postman to test out SOAP web services and checkout its functionality.

## My Other Blogs:
- [Avoid Spring RestTemplate Default Implementation to Prevent Performance Impact](https://dev.to/akdevcraft/never-use-spring-resttemplate-default-implementation-2ghj)
- [Team Agreement in Software Engineering](https://dev.to/akdevcraft/software-engineering-sample-team-agreement-2275)
- [My firsthand experience with web component - learnings and limitations](https://dev.to/akdevcraft/my-firsthand-experience-with-web-component-learnings-and-limitations-4dd8)
- [Streaming logs of all pods at once](https://dev.to/akdevcraft/streaming-logs-from-all-pods-at-once-1kh7)
- [Certified Kubernetes Application Developer (CKAD) Exam Tips](https://dev.to/akdevcraft/certified-kubernetes-application-developer-ckad-exam-tips-4a1b)