Johnson & Johnson (JNJ) came out with quarterly earnings of $2.66 per share, beating the Zacks Consensus Estimate of $2.52 per share. This compares to earnings of $2.55 per share a year ago.

Johnson & Johnson (JNJ) Q3 Earnings and Revenues Surpass Estimates

T-Mobile is planning on automatically moving customers on older plans to newer, more expensive plans, according to a report by the Wall Street Journal, though there is a way for them to opt out.

How To Opt Out Of T-Mobile’s Forced Migration Plan Reportedly Going Into Effect Soon

Johnson & Johnson reported stronger-than-expected third-quarter results. It was the company's first earnings report since completing the Kenvue spin-off. The healthcare giant also boosted its full ...

Johnson & Johnson's Sharper Focus Is Already Paying Dividends for Investors

NEW BRUNSWICK, N.J. (AP) — NEW BRUNSWICK, N.J. (AP) — Johnson & Johnson (JNJ) on Tuesday reported third-quarter profit of $26.03 billion. The New Brunswick, New Jersey-based company said it ...

Johnson & Johnson: Q3 Earnings Snapshot

COVID-19 Vaccine related costs include remaining commitments and obligations, including external manufacturing network exit costs and required clinical trial expenses, associated with the Company's completion of its COVID-19 vaccine contractual commitments ...

Johnson & Johnson Reports Q3 2023 Results

(RTTNews) - Johnson & Johnson (JNJ) released a profit for third quarter that beat the Street estimates. The company's earnings totaled $4.31 billion, or $1.69 per share. This compares with $4.31 ...

Johnson & Johnson Q3 Profit Beats Estimates

Johnson & Johnson raised its full-year financial guidance as it reported its first results since splitting off its consumer health division.

Johnson & Johnson Stock Rises. It Lifts Guidance in First Post-Kenvue Earnings.

IMPD makes 2 quick murder arrests following a pair of overnight homicides. The two cases aren't connected, but police say they do share a common message. Right now, girls are in a disproportionate ...

Shots fired at Johnson County mobile home community

Dentistry Dr. Samuel L. Johnson is a dentist in Mobile, Alabama. He provides advice on proper brushing, flossing, cleaning, healthy gums, and other dental care. It's ideal to visit Dr. Johnson ...

Dr. Samuel L. Johnson

Willow Springs Park recommended venue or other trail of your choice. (YOU MUST USE PDF TICKETS EMAILED FOR EVENT- NO MOBILE APP OR QR CODES ACCEPTED), 1201 Huffine Road, Johnson City, United States

Love & Hiking Date For Couples (Self-Guided) - Johnson City Area

JNJ Mobile (www.MocoSpace.com)

mocospace

Coding Patterns Revealed 

I first discovered way back in 2021 when I built a demo of their APIs for the Adobe Developer blog ( ). Diffbot "Natural Language Processing, Adobe PDF Extract, and Deep PDF Intelligence" At that time, I was impressed with how easy Diffbot's API was and also how quickly it responded. I had not looked at their API in a while, but a few days ago, they announced new support for summarizing text. I thought this would be a great thing to combine with the . Here's what I found. Adobe PDF Extract API First off, if you want to try this yourself, you'll need: Adobe PDF Services . These are free, and you get 500 transactions per month for free. For folks who may not know, I work for Adobe, and this is one of the products I cover. credentials Diffbot . They provide a free two-week trial but no free tier. That being said, I've had to reach out to them a few times when building stuff, and they've provided really great support for me, so I definitely think they're worth you checking out. credentials Alright, let's look at how a summary flow might work. Step One - Extract the Text The (sorry, the "Adobe PDF Extract API", wait, this is my blog, I can shorten things!) is pretty powerful. It uses AI to intelligently parse a PDF to correctly find each and every element detail in the document. Extract API So text, fonts, colors, position, and so forth. It can also find images and tabular data as well which leads to some pretty powerful use cases. (For a good example of this, see my where I scan multiple scientific journals to collect and aggregate astronomical data and create reports.) blog post For this demo, we literally just need the text. For that, I'll make use of the REST APIs. The "flow" for nearly all aspects of the PDF services available are: Exchange credentials for an access token Ask to upload a file for input (in this case, a PDF to be extracted) Upload the document Kick off the job Poll for completion Download the bits Note that there are also SDKs you can use, but I've found our REST APIs so simple I just hit the endpoints directly. Here's the script I wrote to do the Extract process. It's basically everything I said above and pointing to a source PDF in my local filesystem. /*
This demo is a two step process. This file, step one, handles extracting and storing the JSON from a PDF.
*/
import 'dotenv/config';
import fs from 'fs';
import { Readable } from 'stream';
import { finished } from 'stream/promises';

const SOURCE_PDF = '../../source_pdfs/boring_adobe_security_doc.pdf';
const REST_API = "https://pdf-services.adobe.io/";

const CLIENT_ID = process.env.CLIENT_ID;
const CLIENT_SECRET = process.env.CLIENT_SECRET;

async function delay(x) {
	return new Promise(resolve => {
		setTimeout(() => resolve(), x);
	});
}

async function getAccessToken(id, secret) {

	const params = new URLSearchParams();
	params.append('client_id', id);
	params.append('client_secret', secret);

	let resp = await fetch('https://pdf-services-ue1.adobe.io/token', { 
		method: 'POST', 
		headers: {
			'Content-Type':'application/x-www-form-urlencoded'
		},
		body:params 
	});

	let data = await resp.json();
	return data.access_token;
}

async function getUploadData(mediaType, token, clientId) {

	let body = {
		'mediaType': mediaType
	};
	body = JSON.stringify(body);

	let req = await fetch(REST_API+'assets', {
		method:'post',
		headers: {
			'X-API-Key':clientId,
			'Authorization':`Bearer ${token}`,
			'Content-Type':'application/json'
		},
		body: body
	});

	let data = await req.json();
	return data;
}

async function uploadFile(url, filePath, mediaType) {

	let stream = fs.createReadStream(filePath);
	let stats = fs.statSync(filePath);
	let fileSizeInBytes = stats.size;

	let upload = await fetch(url, {
		method:'PUT', 
		redirect:'follow',
		headers: {
			'Content-Type':mediaType, 
			'Content-Length':fileSizeInBytes
		},
		duplex:'half',
		body:stream
	});

	if(upload.status === 200) return;
	else {
		throw('Bad result, handle later.');
	}

}

async function pollJob(url, token, clientId) {

	let status = null;
	let asset; 

	while(status !== 'done') {
		let req = await fetch(url, {
			method:'GET',
			headers: {
				'X-API-Key':clientId,
				'Authorization':`Bearer ${token}`,
			}
		});

		let res = await req.json();

		status = res.status;
		if(status === 'done') {
			asset = res;
		} else {
			await delay(2000);
		}
	}

	return asset;
}

async function downloadFile(url, filePath) {
	let res = await fetch(url);
	const body = Readable.fromWeb(res.body);
	const download_write_stream = fs.createWriteStream(filePath);
	return await finished(body.pipe(download_write_stream));
}

async function extractJob(asset, token, clientId) {
	let body = {
		'assetID': asset.assetID
	}

	let resp = await fetch(REST_API + 'operation/extractpdf', {
		method: 'POST', 
		headers: {
			'Authorization':`Bearer ${token}`, 
			'X-API-KEY':clientId,
			'Content-Type':'application/json'
		},
		body:JSON.stringify(body)
	});

	return resp.headers.get('location');

}

let accessToken = await getAccessToken(CLIENT_ID, CLIENT_SECRET);
console.log('Got our access token.');

let uploadedAsset = await getUploadData('application/pdf', accessToken, CLIENT_ID);

await uploadFile(uploadedAsset.uploadUri, SOURCE_PDF, 'application/pdf');
console.log('Source PDF Uploaded.');

let job = await extractJob(uploadedAsset, accessToken, CLIENT_ID);
console.log('Job created. Now to poll it.');

let result = await pollJob(job, accessToken, CLIENT_ID);
console.log('Job is done.'); 

await downloadFile(result.content.downloadUri, 'extract.json');
console.log('All done.'); Ok, hopefully, you're still reading. In general, I try to avoid posting giant blocks of code like that, but if you focus on the lines at the end, you'll see I'm just hitting utility functions that do what I described in the flow above. Authenticate, ask to upload a PDF, kick off a job, check it, and download the result. One note I'll add. Extract returns a zip file containing a JSON result set, and optionally, tables and images. One nice thing about the REST API is that I can get directly to the JSON and just store it. The JSON result can be quite huge. For my source PDF (an incredibly boring Adobe security document) of three pages, the resulting JSON is 4560 lines long. You can find my source PDF , and the raw output from Extract . here here Instead of putting all 4.5k lines here, let me show a snippet - two unique elements found by the API: {
	"Bounds": [
		44.62139892578125,
		756.9429931640625,
		245.0037841796875,
		766.3184967041016
	],
	"Font": {
		"alt_family_name": "* Arial",
		"embedded": true,
		"encoding": "Identity-H",
		"family_name": "* Arial",
		"font_type": "CIDFontType0",
		"italic": false,
		"monospaced": false,
		"name": "*Arial-6539",
		"subset": false,
		"weight": 400
	},
	"HasClip": false,
	"Lang": "en",
	"Page": 0,
	"Path": "//Document/Sect/P",
	"Text": "Adobe Vendor Security Review Program White Paper ",
	"TextSize": 8.5,
	"attributes": {
		"SpaceAfter": 18
	}
},
{
	"Bounds": [
		0.0,
		0.0,
		630.0,
		820.7799987792969
	],
	"ClipBounds": [
		548.72802734375,
		739.1929931640625,
		602.5444488525391,
		820.7799987792969
	],
	"Page": 0,
	"Path": "//Document/Sect/Figure",
	"attributes": {
		"BBox": [
			548.9779999999737,
			739.4429999999993,
			587.61599999998,
			790.920999999973
		],
		"Placement": "Block"
	}
}, In the sample above, you can see the first element is textual and contains a property, while the second one is a figure. For my demo, I just need to use the property when it exists. Let's see that in action. Text Text Step Two - Create the Summary I mentioned earlier that the Diffbot API was fairly simple to use. Let me demonstrate that. First, I'll set up some variables and read in the JSON I got from the first step. To be clear, I could do everything in one process, but there's really no point in running Extract more than once. What's cool is - I could actually do calls on the result. multiple As an example, one other cool feature Diffbot has is to get entities from text, i.e., what a document is speaking about (people, places, etc). Anyway, here's the beginning: /*
In this file, we take the result from our Extract operation and pass it to Diffbot
*/

import 'dotenv/config';
import fs from 'fs';

const DIFFBOT_KEY = process.env.DIFFBOT_KEY;
const SOURCE_JSON = './extract.json';
const data = JSON.parse(fs.readFileSync(SOURCE_JSON, 'utf8'));

console.log(`Read in source data from ${SOURCE_JSON}.`); Next, I need to parse out the text from the Extract result: let text = data.elements.reduce((text, el) => {
	if(el.Text) text += el.Text + '\n';
	return text;
},''); Next, I craft an HTTP request to Diffbot. Check their for more information. docs let fields = 'summary';
let url = `https://nl.diffbot.com/v1/?fields=${fields}&token=${DIFFBOT_KEY}`;
	
let body = [{
	content:text, 
	lang:'en',
	format:'plain text'
}];

console.log('Passing text to Diffbot.'); 

let req = await fetch(url, { 
	method:'POST',
	body:JSON.stringify(body),
	headers: { 'Content-Type':'application/json' }
});

let result = await req.json(); And that's it. As a final step, I simply output it: console.log(`Summary of PDF:\n${result[0].summary}`); Given the source PDF, the final result is: Adobe has a vendor security review program that evaluates vendors that collect, store, process, 
transmit, or dispose of Adobe data outside of Adobe-controlled physical offices or data center 
locations. The VSR program includes requirements for vendors to follow when handling sensitive 
data and assigns a risk level score to vendors based on their compliance with Adobe standards. 
If a vendor fails the VSR program, Adobe holds discussions with the business owner to understand 
the details of the vendor's security practices and determine whether or not to continue working with them. My three-page PDF is now one simple paragraph. You can imagine how useful this would be for organizations with millions of documents. Combine this with other services (like the entities feature I mentioned previously), and it makes working with large libraries that much easier. Try It! If you want to check this out yourself, you can grab all the code here: . As I said, everything here can be tested for free, so give it a shot, and let me know what you think in a comment below. https://github.com/cfjedimaster/document-services-demos/tree/main/random_demos/extract_diffbot_summary

How to Use AI and PDF Services to Automate Document Summaries

নথির সারাংশ স্বয়ংক্রিয় করতে এআই এবং পিডিএফ পরিষেবাগুলি কীভাবে ব্যবহার করবেন

So nutzen Sie KI- und PDF-Dienste zur Automatisierung von Dokumentzusammenfassungen

Cómo utilizar servicios de IA y PDF para automatizar resúmenes de documentos

Comment utiliser les services AI et PDF pour automatiser les résumés de documents

दस्तावेज़ सारांशों को स्वचालित करने के लिए AI और PDF सेवाओं का उपयोग कैसे करें

AI および PDF サービスを使用して文書の要約を自動化する方法

AI 및 PDF 서비스를 사용하여 문서 요약을 자동화하는 방법

Como usar serviços de IA e PDF para automatizar resumos de documentos

Как использовать сервисы AI и PDF для автоматизации сводки документов

Belge Özetlerini Otomatikleştirmek için Yapay Zeka ve PDF Hizmetleri Nasıl Kullanılır?

Cách sử dụng dịch vụ AI và PDF để tự động hóa việc tóm tắt tài liệu

如何使用 AI 和 PDF 服务自动化文档摘要

The PDF format has become indispensable in modern software, serving as a versatile solution for diverse document types. For businesses seeking secure, editable, and user-friendly PDFs, emerges as a valuable choice. boast a rich array of features catering to various industries. Foxit Foxit’s PDF SDK libraries Web browser-based PDFs, in particular, find myriad applications in document management. They play a pivotal role in numerous banking systems, facilitating tasks such as generating monthly statements. Additionally, the compliance industry relies on web-based PDFs for secure data collection and storage. This tutorial guides you through leveraging the Foxit PDF SDK for Web to craft customized form fields within your web browser PDF documents. The accompanying allows you to follow along and implement the steps outlined in the tutorial. GitHub repository What is Foxit PDF SDK for Web? , among the diverse PDF SDKs offered by Foxit, stands out as an all-encompassing PDF library that leverages the advantages of Foxit’s rendering engine. This SDK empowers you to seamlessly integrate a comprehensive and fully customizable PDF viewer into your applications. The Foxit PDF SDK for Web Web PDFs crafted with Foxit’s SDK enable users to effortlessly view, fill out, annotate, and sign documents in various languages directly from their mobile or desktop browsers using JavaScript. The SDK is compatible with all major browsers, including Firefox, Safari, Chrome, and Opera. To illustrate the functionality, you will embark on creating a new PDF project from a template, employing the Foxit PDF SDK for Web to provide the necessary structure. This hands-on approach will offer a practical demonstration of how the SDK enhances PDF capabilities within your web-based projects. Implementing Foxit PDF SDK for Web Foxit PDF SDK for Web. The ZIP file should contain the SDK, documentation and examples. Download You can preview these examples by running an HTTP server from the unzipped directory. # NPX available with NPM v5.2 or newer
npx http-server Setup the Project This tutorial uses for frontend tooling. It’s based on ES modules (ESM), fast, and comes with everything you need to use the SDK out of the box. To create a new project from a template and start the development server, make sure you’ve got Node.js version 12.2.0 or newer and run the following commands: Vite npm create vite@latest project -- --template vanilla
cd project
npm install
npm run dev Move the SDK into the created directory. For the rest of this tutorial, the SDK is assumed to be available at , relative to the parent directory. ./FoxitPDFSDKForWeb project Loading the PDF You will need a PDF viewer with a document uploaded to begin experimenting. To initialize the PDF viewer, first create the HTML structure and load the SDK. 

<body>
<div class="container">
<div id="viewer"></div>
<div id="menu"></div>
</div>
<script src="./FoxitPDFSDKForWeb/lib/PDFViewCtrl.full.js"></script>
<script type="module" src="/main.js"></script>
</body>
 Additionally, in , add some CSS to style the elements: style.css /* style.css */
html {
height: 100%;
}b
ody {
height: 100%;
margin: 0;
}.
container {
width: 100%;
height: 100%;
display: flex;
}#
viewer {
height: 100%;
flex: 1;
overflow: auto;
}#
menu {
width: 10rem;
}.
menu-element {
background: #f1f5f9;
padding: 1rem;
display: flex;
justify-content: center;
align-items: center;font-family: monospace;
margin: 0.5rem;
} Inside , use the SDK to create an instance of the : main.js pdfViewer import "./style.css";
const licenseSN = "...";
const licenseKey = "...";
const viewerContainer = document.getElementById("viewer");
const pdfViewer = new PDFViewCtrl.PDFViewer({
libPath: "./FoxitPDFSDKForWeb/lib",
jr: {
licenseSN,
licenseKey,
},
customs: {
ScrollWrap: PDFViewCtrl.CustomScrollWrap.create(viewerContainer),
},
}); You can find your values for and inside the file. licenseSN licenseKey ./FoxitPDFSDKForWeb/examples/license-key.js The pdfViewer is created by providing the constructor with a configuration object containing: The relative path to the folder of the unzipped SDK package libPath: lib Config options for the JR engine that include, most importantly, licensing information jr: A custom component that controls PDF sizing and scrolling, where setting it adjusts the viewer to the container customs.ScrollWrap: With created, all you have to do is initialize it and load the document: pdfViewer // ...
const loadPDF = async (url) => {
const response = await fetch(url);
const blob = await response.blob();return pdfViewer.openPDFByFile(blob);
};
pdfViewer.init(viewerContainer);
loadPDF("./FoxitPDFSDKForWeb/docs/FoxitPDFSDKforWeb_DemoGuide.pdf"); The above snippet fetches the PDF file as a and opens it in the viewer using its method. The PDF document used is a demo guide from the SDK’s included documentation. blob openPDFByFile() The additional space on the right will serve as a menu for draggable form fields. Creating Custom Form Fields All you need to create a form field with the Foxit SDK is a viewer, the form field’s metadata (such as field type or select options), and the form field position. For this example, you’ll create a set of predefined form fields with ready metadata that the user can drag and drop into the viewer. Defining Metadata Start by defining the metadata for allowed fields, as well as additional helpers: // ...
const menuContainer = document.getElementById("menu");
const randomId = () => `_${Math.random().toString(36).substring(2, 9)}`;
const FieldTypes = PDFViewCtrl.PDF.form.constant.Field_Type;
const formFields = [
{
label: "Push Button",
name: "push-button",
type: FieldTypes.PushButton,
width: 50,
height: 30,
},
{
label: "Checkbox",
name: "checkbox",
type: FieldTypes.CheckBox,
width: 50,height: 30,
},
{
label: "Radio Button",
name: "radio-button",
type: FieldTypes.RadioButton,
width: 80,
height: 30,
},
{
label: "Combo Box",
name: "combo-box",
type: FieldTypes.ComboBox,
width: 60,
height: 30,
},
{
label: "List Box",
name: "list-box",
type: FieldTypes.ListBox,
width: 60,
height: 100,
},
{
label: "Text",
name: "text",
type: FieldTypes.Text,
width: 60,
height: 30,
},
];
const comboBoxOptions = [
{ label: "10", value: "10", selected: true, defaultSelected: true },
{ label: "20", value: "20", selected: false, defaultSelected: false },
{ label: "30", value: "30", selected: false, defaultSelected: false },
{ label: "40", value: "40", selected: false, defaultSelected: false },
];
const listBoxOptions = comboBoxOptions; The function will generate IDs to identify form fields within the document. is a shortcut for faster reference of predefined field types available in the SDK. Each form field entry contains: randomId() FieldTypes A to inform the user about its use label A for matching dragged elements to the metadata entries name A to indicate the field’s type type A and for calculating the position rectangle within the PDF width height Lastly, comboBoxOptions and listBoxOptions contain sample options for fields that require users to select one. Creating Drag and Drop Elements With the metadata ready, you can create a function for handling the logic of drag and drop, as well as the form field placement: // ...
const loadFormFieldsMenu = async (PDFDoc) => {
const PDFForm = await PDFDoc.loadPDFForm();
formFields.forEach((formField) => {
const element = document.createElement("div");
element.draggable = true;
element.id = formField.name;
element.classList.add("menu-element");
element.textContent = formField.label;
element.addEventListener("dragstart", (event) => {
event.dataTransfer.setData("text/plain", event.target.id);
});
menuContainer.append(element);
});
}; The function accepts —an SDK object representing a PDF document—as an argument. It’s used to retrieve a object, which will be used to add and configure the form fields, after those fields are processed into draggable elements and added to the side menu. PDFDoc PDFForm Each element has a attribute set to to allow for dragging, as well as an corresponding to each form field’s unique name to match them with the underlying metadata. This is later used inside the event listener to transfer it during the drag and drop action. draggable true id id dragstart To get the parameter required for the function, you’ll have to get the resulting of the function by modifying it as below: PDFDoc loadFormFieldsMenu() promise loadPDF() // ...
loadPDF("./FoxitPDFSDKForWeb/docs/FoxitPDFSDKforWeb_DemoGuide.pdf").then(
(PDFDoc) => {
loadFormFieldsMenu(PDFDoc);
}
); With the menu items created, the app now looks like this: Implementing Drag & Drop Functionality Having created the draggable elements, it’s time to fully implement the drag and drop functionality and allow for creating form fields in the viewer: // ...
const loadFormFieldsMenu = async (PDFDoc) => {
// ...
viewerContainer.addEventListener("dragover", (event) => {
event.preventDefault();
});
viewerContainer.addEventListener("drop", async (event) => {
event.preventDefault();
const droppedFormFieldName = event.dataTransfer.getData("text/plain");
const formField = formFields.find(
({ name }) => name === droppedFormFieldName
);
const pos = await pdfViewer.convertClientCoordToPDFCoord({
clientX: event.clientX,
clientY: event.clientY,
});
const id = randomId();await PDFForm.addControl(pos.index, id, formField.type, {
left: pos.left - formField.width / 2,
right: pos.left + formField.width / 2,
top: pos.top + formField.height / 2,
bottom: pos.top - formField.height / 2,
});
const field = PDFForm.getField(id);
if (formField.type === FieldTypes.ComboBox) {
field.setOptions(comboBoxOptions);
} else if (formField.type === FieldTypes.ListBox) {
field.setOptions(listBoxOptions);
}
});
};
// ... In the above code, the event listener forwards the interaction to be handled in the event by calling . dragover drop preventDefault() Inside the event handler, the matching metadata is first retrieved using the dragged element’s data. Then, the mouse position from the event is transformed into PDF coordinates using the method available on the instance. drop convertClientCoordToPDFCoord() pdfViewer The position, metadata, and randomly generated ID are used in the method call from the object created earlier in the function. The method accepts the following arguments: addControl() PDFForm The index of the page to place the form field at (retrieved from call) convertClientCoordToPDFCoord() The randomly generated ID for the newly created form field The type of the form field according to provided constants (retrieved from metadata) The argument that defines the placement for the form field in the form of a rectangle, calculated using and to make the mouse coordinates the form field’s center width height Finally, in case the field accepts a list of options, it’s first accessed by the method of the object using the ID. The options are set accordingly using the method. getField() PDFForm setOptions() The final app, with a few form fields already placed, looks like this: Conclusion Adding functionality to your PDFs can indeed bring significant benefits to your organization and users. Electronic updates and signatures save time, money, and effort, while customized and secure documents enhance trust in your company. As demonstrated earlier, multilingual PDF tool, coupled with the Foxit PDF SDK for Web, provides a robust solution. You can create custom form fields, implement drag-and-drop functionality, and unlock a range of capabilities. However, this is just the tip of the iceberg. The Foxit PDF SDK for Web offers a comprehensive set of features for further enhancing your PDF functionality. Foxit’s To delve deeper into the possibilities, refer to the and additional resources provided by the SDK. The documentation will guide you through advanced features, customization options, and best practices. official documentation If you want to review the tutorial or check your work, you can refer to the associated with the tutorial. The repository likely contains the source code, examples, and additional materials to help you understand and implement the concepts covered in the tutorial. GitHub repository Also published . here

A Guide to Creating Custom Form Fields Using the Foxit PDF SDK for Web

ওয়েবের জন্য Foxit PDF SDK ব্যবহার করে কাস্টম ফর্ম ফিল্ড তৈরি করার জন্য একটি গাইড

Eine Anleitung zum Erstellen benutzerdefinierter Formularfelder mit dem Foxit PDF SDK for Web

Una guía para crear campos de formulario personalizados utilizando Foxit PDF SDK para Web

Un guide pour créer des champs de formulaire personnalisés à l'aide du SDK Foxit PDF pour le Web

वेब के लिए फॉक्सिट पीडीएफ एसडीके का उपयोग करके कस्टम फॉर्म फ़ील्ड बनाने के लिए एक गाइड

Foxit PDF SDK for Webを使用してカスタムフォームフィールドを作成するためのガイド

웹용 Foxit PDF SDK를 사용하여 사용자 정의 양식 필드를 만드는 방법에 대한 안내

Um guia para criar campos de formulário personalizados usando o Foxit PDF SDK for Web

Руководство по созданию настраиваемых полей формы с помощью Foxit PDF SDK для Интернета

Web için Foxit PDF SDK'yı Kullanarak Özel Form Alanları Oluşturma Kılavuzu

Hướng dẫn tạo trường biểu mẫu tùy chỉnh bằng Foxit PDF SDK cho web

使用 Foxit PDF SDK for Web 创建自定义表单字段的指南

Debian GNU/Linux: Guide to Installation and Usage" by John Goerzen and Ossama Othman is part of the HackerNoon Books Series. You can jump to any chapter in this book . Introduction here 1. Introduction We’re glad to have this opportunity to introduce you to Debian! As we begin our journey down the road of GNU/Linux, we’d like to first talk a bit about what exactly Debian is—what it does, and how it fits in with the vast world of Free Software. Then, we talk a bit about the phenomenon that is Free Software and what it means for Debian and you. Finally, we close the chapter with a bit of information about this book itself. 1.1 What Is Debian? is a free operating system (OS) for your computer. An operating system is the set of basic programs and utilities that make your computer run. At the core of an operating system is the . The kernel is the most fundamental program on the computer: It does all the basic housekeeping and lets you start other programs. Debian uses the kernel, a completely free piece of software started by Linus Torvalds and supported by thousands of programmers worldwide. A large part of the basic tools that fill out the operating system come from the GNU Project , and these tools are also free. Debian kernel Linux [1] http://www.gnu.org/ [1] Another facet of an operating system is application software: programs that help get work done, from editing documents to running a business to playing games to writing more software. Debian comes with more than 1,500 (precompiled software bundled up in a nice format for easy installation on your machine)—all for free. packages The Debian system is a bit like a pyramid. At the base is Linux. On top of that are all the basic tools, mostly from GNU. Next is all the application software that you run on the computer; many of these are also from GNU. The Debian developers act as architects and coordinators—carefully organizing the system and fitting everything together into an integrated, stable operating system: Debian GNU/Linux. The design philosophy of GNU/Linux is to distribute its functionality into small, multipurpose parts. That way, you can easily achieve new functionality and new features by combining the small parts (programs) in new ways. Debian is like an erector set: You can build all sorts of things with it. When you’re using an operating system, you want to minimize the amount of work you put into getting your job done. Debian supplies many tools that can help, but only if you know what these tools do. Spending an hour trying to get something to work and then finally giving up isn’t very productive. This guide will teach you about the core tools that make up Debian: what tools to use in certain situations and how to tie these various tools together. 1.1.1 Who Creates Debian? Debian is an all-volunteer Internet-based development project. There are hundreds of volunteers working on it. Most are in charge of a small number of software packages and are very familiar with the software they package. These volunteers work together by following a strict set of guidelines governing how packages are assembled. These guidelines are developed cooperatively in discussions on Internet mailing lists. 1.2 A Multiuser, Multitasking Operating System As we mentioned earlier in section 1.1, the design of Debian GNU/Linux comes from the Unix operating system. Unlike common desktop operating systems such as DOS, Windows, and MacOS, GNU/Linux is usually found on large servers and systems. multiuser This means that Debian has features those other operating systems lack. It allows a large number of people to use the same computer at once, as long as each user has his or her own . To permit many users to work at once, Debian must allow many programs and applications to run simultaneously. This feature is called . terminal [2] multitasking A terminal is just a keyboard and a screen that are connected to the computer through the network, over a modem, or directly. You keyboard and monitor form a terminal that is directly attached to the computer: This special terminal is often called the . [2] console Much of the power (and complexity) of GNU/Linux systems stems from these two features. For example, the system must have a way to keep users from accidentally deleting each other’s files. The operating system also must coordinate the many programs running at once to ensure that they don’t all use the same resource, such as a hard drive, at the same time. If you keep in mind what Debian was originally designed to do, many aspects of it will make a lot more sense. You’ll learn to take advantage of the power of these features. 1.3 What Is Free Software? When Debian developers and users speak of “Free Software,” they refer to rather than price. Debian is free in this sense: You are free to modify and redistribute it and will always have access to the source code for this purpose. The Debian Free Software Guidelines describe in more detail exactly what is meant by “free.” The Free Software Foundation , originator of the GNU Project, is another excellent source of information. You can find a more detailed discussion of free software on the Debian web site . One of the most well-known works in this field is Richard M. Stallman’s essay, ; take a look at it for some insight into why we support Free Software as we do. Recently, some people have started calling Free Software “Open Source Software”; the two terms are interchangable. freedom [3] [4] [5] Why Software Should Be Free [6] http://www.debian.org/social_contract#guidelines [3] http://www.fsf.org/ [4] http://www.debian.org/ [5] http://www.fsf.org/philosophy/shouldbefree.html [6] You may wonder why would people spend hours of their own time writing software and carefully packaging it, only to give it all away. The answers are as varied as the people who contribute. Many believe in sharing information and having the freedom to cooperate with one another, and they feel that free software encourages this. A long tradition that upholds these values, sometimes called the Hacker Ethic, started in the 1950s. The Debian GNU/Linux Project was founded based on these Free Software ethics of freedom, sharing, and cooperation. [7] Note that the term “hacker” should not be confused with the term “cracker.” In short, a hacker is benevolent, whereas a cracker is generally considered malevolent. Movies and other forms of media many times incorrectly use the term “hacker” instead of “cracker.” [7] Others want to learn more about computers. More and more people are looking for ways to avoid the inflated price of proprietary software. A growing community contributes in appreciation for all the great free software they’ve received from others. Many in academia create free software to help get the results of their research into wider use. Businesses help maintain free software so they can have a say in how it develops—there’s no quicker way to get a new feature than to implement it yourself or hire a consultant to do so! Business is also interested in greater reliability and the ability to choose between support vendors. Still others see free software as a social good, democratizing access to information and preventing excessive centralization of the world’s information infrastructure. Of course, a lot of us just find it great fun. Debian is so committed to free software that we thought it would be useful if it was formalized in a document of some sort. Our Social Contract promises that Debian will always be 100% free software. When you install a package from the Debian main distribution, you can be sure it meets our Free Software Guidelines. [8] http://www.debian.org/social_contract [8] Although Debian believes in free software, there are cases where people want to put proprietary software on their machine. Whenever possible Debian will support this; though proprietary software is not included in the main distribution, it is sometimes available on the FTP site in the non-free directory, and there is a growing number of packages whose sole job is to install proprietary software we are not allowed to distribute ourselves. It is important to distinguish software from software. Proprietary software is non-free software; commercial software is software sold for money. Debian permits commercial software, but not proprietary software, to be a part of the main distribution. Remember that the phrase “free software” does not refer to price; it is quite possible to sell free software. For more clarification of the terminology, see http://www.opensource.org/or http://www.fsf.org/philosophy/categories.html. commercial proprietary 1.4 About This Book This book is aimed at readers who are new to Debian GNU/Linux. It assumes no prior knowledge of GNU/Linux or other Unix-like systems, but it does assume very basic general knowledge about computers and hardware; you should know what the basic parts of a computer are, and what one might use a computer to do. In general, this tutorial tries to help you understand what happens inside a Debian system. The idea is to empower you to solve new problems and get the most out of your computer. Thus there’s plenty of theory and fun facts thrown in with the “How To” aspects of the manual. We’d love to hear your comments about this book! You can reach the authors at debian-guide@complete.org. We’re especially interested in whether it was helpful to you and how we could make it better. Whether you have a comment or think this book is the greatest thing since sliced bread, please send us e-mail. Please do not send the authors technical questions about Debian, because there are other forums for that; see Appendix A on page [*] for more information on the documentation and getting help. Only send mail regarding the book itself to the above address. 1.4.1 How to Read This Book The best way to learn about almost any computer program is by using it. Most people find that reading a book without using the program isn’t beneficial. The best way to learn about Unix and GNU/Linux is by using them. Use GNU/Linux for everything you can. Feel free to experiment! Debian isn’t as intuitively obvious as some other operating systems. You will probably end up reading at least the first few chapters of this book. GNU/Linux’s power and complexity make it difficult to approach at first, but far more rewarding in the long run. The suggested way to learn is to read a little, and then play a little. Keep playing until you’re comfortable with the concepts, and then start skipping around in the book. You’ll find a variety of topics are covered, some of which you might find interesting. After a while, you should feel confident enough to start using commands without knowing exactly what they do. This is a good thing. Tip: If you ever mistakenly type a command or don’t know how to exit a program, press CTRL-c (the Ctrl key and the lowercase letter c pressed simultaneously). This will often stop the program. 1.4.2 Conventions Before going on, it’s important to be familiar with the typographical conventions used in this book. When you should simultaneously hold down multiple keys, a notation like CTRL-a will be used. This means “press the Ctrl key and press lowercase letter a.” Some keyboards have both Alt and Meta; most home computers have only Alt, but the Alt key behaves like a Meta key. So if you have no Meta key, try the Alt key instead. Keys like Alt and Meta are called keys because they change the meaning of standard keys like the letter A. Sometimes you need to hold down more than one modifier; for example, Meta-Ctrl-a means to simultaneously press Meta, Ctrl, and lowercase a. modifier Some keys have a special notation—for example, Ret (Return/Enter), Del (Delete or sometimes Backspace), Esc (Escape). These should be fairly self-explanatory. Spaces used instead of hyphens mean to press the keys in sequential order. For example, CTRL-a x RET means to simultaneously type Ctrl and lowercase a, followed by the letter x, followed by pressing Return. (On some keyboards, this key is labeled Enter. Same key, different name.) In sample sessions, bold face text denotes characters typed by the user, italicized text denotes comments about a given part of the sample session, and all other text is output from entering a command. For shorter commands, you’ll sometimes find that the command can be found within other text, highlighed with a monospace font. About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. This book is part of the public domain. John Goerzen and Ossama Othman (2004). Debian GNU/Linux : Guide to Installation and Usage. Urbana, Illinois: Project Gutenberg. Retrieved https://www.gutenberg.org/cache/epub/6527/pg6527-images.html This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at , located at . www.gutenberg.org https://www.gutenberg.org/policy/license.html

We’re glad to have this opportunity to introduce you to Debian!

In , I introduced SECST ( emantic, omputational, tyled, agged) markup, a more expressive alternative to- and partial superset of- Markdown. Although it does not cover in detail the Markdown compatibility of SECST, you may want to read it first to get a basic grasp of SECST syntax. In this article, I introduce the power of SECST computational markup. The Joy of Using SECST Markup S C S T Readers who know about and will be familiar with computational notebooks based on Markdown. These platforms are primarily focused on data professionals, and they are quite frankly awesome! Jupyter Observable But, what if … You are not a data professional and just want some math in your document and need to ensure the values for formulas are correct! You are a teacher who needs to write a math tutorial. You are a data scientist, but you sometimes need something lighter weight that does not require special hosting or a subscription. Then, you may get joy from SECST's computational capabilities. Basic Computations At their most basic level, SECST computations are no more complex than simple Excel formulas. will render as :value[2 * 2] 4 The result will have code styling (usually in monospace font with a grey background) to indicate to readers the value is computed. However, you can provide as an option, e.g. plaintext will render as 4. :value(plaintext)[2 * 2] SECST also has the full expressive power of Excel and more when it comes to math formulas. Here are all the types of computations available: Algebraic Arithmetic Bitwise Combinatorics Complex Geometry Logical Matrix Probability Relational Set Special Statistics String Trigonometry Unit Utility To be fair, this is just because SECST makes use of the library. But, SECST authors do not need to worry about how to include the functionality. It is just there, so things like this are possible: MathJS renders as 2 * x + 1. :value(plaintext)[derivative('x^2 + x', 'x')] renders as 2 * x ^ 2 + x + 3. :value(plaintext)[simplify('x^2 + x + 3 + x^2')] renders as 9. :value(plaintext)[solve('Math.pow(r,2)',{r:3})}] renders as [[7,8],[19,22]]. :value(plaintext)[multiply([[1,2],[3,4]],[[5,6],[1,1]])] Unit conversions like this are also possible: = :value[2 inch to cm] 5.08 cm = :value[90 km/h to mi/h] 55.92340730136006 mi / h = is meters per hour :value[90 km/h to m/h] 9000 m / h m / h = :value[(1 week + 1 day) to days] 8 days = :value[cos(45 deg)] 0.7071067811865476 = :value[8.314 m^3 Pa / mol / K] 8.314 (m^3 Pa) / (mol K) Advanced Computations You can name values so they can be used in other value expressions.  And, it is possible to have readers edit content for use in formulas. Here is an example that covers both cases: The derivative of :value(#formula literal editable)[x^2 + x]
for :value(#variable literal editable)[x]
is :value[derivative($(#formula),$(#variable))] will render as: The derivative of [ x^2 + x ] for [ x ] is 2 * x + 1 Unless the user modifies the formula to be , in which case the result will be . x^3 + x 3 * x^2 + 1 This is obviously a bit more complex than the unit conversion, so here is the explanation … Value tags provide the user with an edit box when configured as . editable Values can be named using . Above we name the formula to be entered and the variable to solve for . #ids #formula #variable By default, the content between the square braces for a tag is considered to be an expression that can be evaluated. So, in the above, SECST is instructed to treat the content as a . :value[] literal Finally, named variables can be accessed in expressions using the syntax . Hence, the final step above is to evaluate using the formula and variable entered by the reader. :value $(#<variable-name>) derivative Interactive Questions SECST even has the ability to render questions and check answers. :question({type:"number",showanswer:true})[
  :text[What is the :code[sqrt(4)]?]
  :answer[2]
] will render as What is the sqrt(4)? [ ____ ] ✓ If the user enters the wrong answer, the question will be boxed in red and the correct answer will be shown because the attribute is set to . showanswer true What is the sqrt(4)? [ 3 ] ✓ Correct Answer: 2 If you are a teacher, I am sure at some point you have provided the wrong answer in a tutorial. SECST can help avoid this. The tag can take an expression just like the tag. Replace the above question with: :answer :value :question({type:"number",showanswer:true})[
  :text[What is the :code[sqrt(4)]?]
  :answer[sqrt(4)]
] More Info Not yet available, but just days away, are REPLs. See the article, for a preview. I will post a SECST-specific story when it is ready. How To Host A REPL The SECST language and transpiler are currently in ALPHA under an AGPL v3.0 license. There is more to explore at . https://secst.org Be joyful! Make yesterday jealous! I would love your feedback here or on . GitHub Featured Photo by on Bekka Mongeau Pexels

The Joy Of Computational Markup

How To Build An NFT Minting Dapp On Flow

is a distributed, RESTful search and analytics engine that can handle an expanding range of use cases. It offers a full-text search engine with a multitenant capability, an HTTP web interface, and schema-free JSON documents, all with simple installation. Elasticsearch Elasticsearch is a search engine based on the Lucene library. It provides a distributed, multitenant-capable full-text search engine with an HTTP web interface and schema-free JSON documents. In this article, I will be walking you through how to set up elasticsearch on your PC. How to setup, install, and configure Elasticsearch for Mac In order to download Elasticsearch, go to the , select the respective operating system and click on the download button as shown below: Elasticsearch Download Page After downloading, extract the compressed file using the command below: $ tar -xzvf elasticsearch-8.4.1-darwin-aarch64.tar.gz Configuring Elasticsearch After extracting elasticsearch, depending on your use case, you may want to configure elasticsearch to suit you. You can take a look at the config file using the command below: $ vi elasticsearch-8.4.1/config/elasticsearch.yml You can have multiple nodes in your cluster, in order to do this, you need to ensure that the cluster name on your nodes matches. Cluster: # -------------------------------- Cluster ----------------------------------
#
# Use a descriptive name for your cluster:
#
cluster.name: air-elastic
# This is an identifier for the individual nodes in your cluster Node: # -------------------------------- Node ----------------------------------
#
# Use a descriptive name for your cluster:
#
node.name: airscholar-node
# For other configurations, check to fine-tune the configs to suit your use case. elasticsearch.yml Starting up Elasticsearch In order to start up elasticsearch engine use the command below: $ bin/elasticsearch When starting up for the first time, you will be presented with a password that needs to be changed: elasticsearch Changing your password for the first time You should change your password after starting up the elasticsearch for the first time, of course, you can do that using this command: bin/elasticsearch-reset-password -u elastic NOTE: ENSURE YOU KEEP YOUR ELASTIC PASSWORD SAFE, IT WILL BE REQUIRED IN ORDER TO CONNECT TO ELASTICSEARCH Testing Elasticsearch In your browser, goto or the specified hostname and port in your . You will be asked for (elastic) and (the password you changed to when starting elasticsearch for the first time) https://localhost:9200 elasticonfig.yml username password You should see something like this: {
  "name" : "airscholar-node",
  "cluster_name" : "air-elastic",
  "cluster_uuid" : "7g3LmMYFRmyxTyR6ZI-b7A",
  "version" : {
    "number" : "8.4.1",
    "build_flavor" : "default",
    "build_type" : "tar",
    "build_hash" : "2bd229c8e56650b42e40992322a76e7914258f0c",
    "build_date" : "2022-08-26T12:11:43.232597118Z",
    "build_snapshot" : false,
    "lucene_version" : "9.3.0",
    "minimum_wire_compatibility_version" : "7.17.0",
    "minimum_index_compatibility_version" : "7.0.0"
  },
  "tagline" : "You Know, for Search"
} If you have any challenges setting up elasticsearch, feel free to drop a comment, and I will try to respond. You can also check the for more detailed information about elasticsearch. official elasticsearch documentation Kibana Kibana is a source-available data visualization dashboard software for Elasticsearch, whose free and open source successor in OpenSearch is OpenSearch Dashboards. How does Kibana help us in this case you may ask? is a great visualization tool that helps us with our elasticsearch queries and manipulation. It is part of B.E.L.K (Beats, Elasticsearch, Logstash, and Kibana) stack. In case you don't know much about it, follow along and you will be just fine! (A separate article on Kibana can be written as an addendum to this series if you want, let me know in the comment section!) Kibana Setting up and Configuring Kibana In order to download Kibana, go to , and click on the download button. Kibana Download Page After downloading, extract the zip file using this command: $ tar -xzvf kibana-8.4.1-darwin-aarch64.tar.gz
$ cd kibana-8.4.1 There are two ways to configure and connect Kibana to elasticsearch, one way is to manually input the required keys into (in ) or run Kibana and configure it on the UI. I'm choosing the latter 😉! kibana.yml config/kibana.yml Run kibana using this command: bin/kibana When starting Kibana for the first time, you will be presented with this screen: There are two ways to tackle this; Use the elastic enrollment token (usually generated on your terminal when starting elastic for the first time) see below; Copy and paste the enrollment token above to Kibana and click . You will be fine. Configure Elastic Manually configure Kibana with elastic using the elastic URL. Click on check address and click . Configure elastic Enter password generated. Or click forgot password (if you can not recall the password), and paste the command below to your terminal to reset the password. kibana_system bin/elasticsearch-reset-password --username kibana_system You will be asked to enter a verification code and check your terminal (where you are running kibana to retrieve it) That's it! You are all set up. Enter your elastic username and password to log in to kibana and you are in! Querying elastic using Kibana Let's run a sample query to test our connection, shall we? Click on the hamburger (three lines on the top left corner of your screen) Scroll down to the bottom of the page Click on Dev tools You should see something like this: On the left pane is where queries are written, and the right pane is where the outputs are presented. Ensure you click on any part of the query and select the play button. The output of the query will be presented on the right pane. Loading data into elasticsearch To enable us to write our code effectively, we need data loaded into our . We will be using a sample dataset from Kaggle ( ). elasticsearch Download it here Follow the FOUR steps below to load it up into elasticsearch: Open up Kibana ( ) http://localhost:5601 Under Click on Upload a file: Get started by adding integrations Click on import and enter the name of the index you want to put the data in. Click on import (final page) If you made it to this point, you have successfully imported data into elasticsearch. Querying for sample Goto DevTools (Hamburger on the top left corner of the screen > Scroll down to Management > DevTools) Run the query below (select it and click on the play button) GET tmdb_movies/_search If you see this, we are good to go! Now, Let's dive into coding, shall we 😊? NestJS NestJS is a progressive Node. js framework that helps build server-side applications. Nest extends Node. js frameworks like Express or Fastify adding modular organization and a wide range of other libraries to take care of repetitive tasks. It's open-source, uses TypeScript, and is a very versatile Node. Creating a NestJs Application Run the command below to install nestcli and create a new NestJs Application (in the article, the name of the app will be nest-elastic). $ npm i -g @nestjs/cli
$ nest new nest-elastic You will be asked to select a package manager, you can select npm, yarn, or pnpm. I will be selecting yarn (you can choose any other one you want 😉). Your project will be set up and we should be ready to code! Adding elasticsearch to your app Run the command below to add elasticsearch to your and other dependencies: nest-elastic yarn add @elastic/elasticsearch @nestjs/elasticsearch @nestjs/config In your root folder add your file with the following contents: .env ELASTICSEARCH_NODE=https://localhost:9200
ELASTICSEARCH_USERNAME=elastic
ELASTICSEARCH_PASSWORD=elasticPasswordGoesHere
ELASTICSEARCH_MAX_RETRIES=10
ELASTICSEARCH_REQ_TIMEOUT=50000
ELASTICSEARCH_INDEX=tmdb_movies Let's create a separate module that handles only search using elasticsearch. A simple shortcut is to use the command below (you are welcome to do it manually if you want to): nest g resource search Update the to have the content below: search.module.ts import { Module } from '@nestjs/common';
import { SearchService } from './search.service';
import { SearchController } from './search.controller';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { ElasticsearchModule } from '@nestjs/elasticsearch';

@Module({
  imports: [
    ConfigModule,
    ElasticsearchModule.registerAsync({
      imports: [ConfigModule],
      useFactory: async (configService: ConfigService) => ({
        node: configService.get('ELASTICSEARCH_NODE'),
        auth: {
          username: configService.get('ELASTICSEARCH_USERNAME'),
          password: configService.get('ELASTICSEARCH_PASSWORD'),
        },
        maxRetries: configService.get('ELASTICSEARCH_MAX_RETRIES'),
        requestTimeout: configService.get('ELASTICSEARCH_REQ_TIMEOUT'),
      }),
      inject: [ConfigService],
    }),
  ],
  controllers: [SearchController],
  providers: [SearchService],
  exports: [SearchService],
})
export class SearchModule {} Update with the content below: search.service.ts import { ConfigService } from '@nestjs/config';
import { Injectable } from '@nestjs/common';
import { ElasticsearchService } from '@nestjs/elasticsearch';

type dataResponse = {
  UnitPrice: number;
  Description: string;
  Quantity: number;
  Country: string;
  InvoiceNo: string;
  InvoiceDate: Date;
  CustomerID: number;
  StockCode: string;
};

@Injectable()
export class SearchService {
  constructor(
    private readonly esService: ElasticsearchService,
    private readonly configService: ConfigService,
  ) {}

  async search(search: {key: string}) {
    let results = new Set();
    const response = await this.esService.search({
      index: this.configService.get('ELASTICSEARCH_INDEX'),
      body: {
        size: 50,
        query: {
          match_phrase: search
        },
      },
    });
    const hits = response.hits.hits;
    hits.map((item) => {
      results.add(item._source as dataResponse);
    });

    return { results: Array.from(results), total: response.hits.total };
  }
} Now, let's add movies modules: nest g resource movies Update with the content below: movies.controller.ts import { SearchService } from './../search/search.service';
import { Body, Controller, Post } from '@nestjs/common';

@Controller('movies')
export class MoviesController {
  constructor(private readonly searchService: SearchService) {}

  @Post('search')
  async search(@Body() body) {
    return await this.searchService.search(body.data);
  }
} Then movies.module.ts import { SearchModule } from './../search/search.module';
import { Module } from '@nestjs/common';
import { MoviesService } from './movies.service';
import { MoviesController } from './movies.controller';

@Module({
  imports: [SearchModule],
  controllers: [MoviesController],
  providers: [MoviesService],
})
export class MoviesModule {} Finally, update app.module.ts import { MoviesModule } from './movies/movies.module';
import { ConfigModule } from '@nestjs/config';
import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { SearchModule } from './search/search.module';

@Module({
  imports: [MoviesModule, ConfigModule.forRoot(), SearchModule],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {} Your should look like this: package.json {
  "name": "nest-elastic",
  "version": "0.0.1",
  "description": "",
  "author": "Yusuf Ganiyu",
  "private": true,
  "license": "UNLICENSED",
  "scripts": {
    "prebuild": "rimraf dist",
    "build": "nest build",
    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
    "start": "nest start",
    "start:dev": "nest start --watch",
    "start:debug": "nest start --debug --watch",
    "start:prod": "node dist/main",
    "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
    "test": "jest",
    "test:watch": "jest --watch",
    "test:cov": "jest --coverage",
    "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
    "test:e2e": "jest --config ./test/jest-e2e.json"
  },
  "dependencies": {
    "@elastic/elasticsearch": "^8.4.0",
    "@nestjs/common": "^9.0.0",
    "@nestjs/config": "^2.2.0",
    "@nestjs/core": "^9.0.0",
    "@nestjs/elasticsearch": "^9.0.0",
    "@nestjs/mapped-types": "*",
    "@nestjs/platform-express": "^9.0.0",
    "reflect-metadata": "^0.1.13",
    "rimraf": "^3.0.2",
    "rxjs": "^7.2.0"
  },
  "devDependencies": {
    "@nestjs/cli": "^9.0.0",
    "@nestjs/schematics": "^9.0.0",
    "@nestjs/testing": "^9.0.0",
    "@types/express": "^4.17.13",
    "@types/jest": "28.1.4",
    "@types/node": "^16.0.0",
    "@types/supertest": "^2.0.11",
    "@typescript-eslint/eslint-plugin": "^5.0.0",
    "@typescript-eslint/parser": "^5.0.0",
    "eslint": "^8.0.1",
    "eslint-config-prettier": "^8.3.0",
    "eslint-plugin-prettier": "^4.0.0",
    "jest": "28.1.2",
    "prettier": "^2.3.2",
    "source-map-support": "^0.5.20",
    "supertest": "^6.1.3",
    "ts-jest": "28.0.5",
    "ts-loader": "^9.2.3",
    "ts-node": "^10.0.0",
    "tsconfig-paths": "4.0.0",
    "typescript": "^4.3.5"
  },
  "jest": {
    "moduleFileExtensions": [
      "js",
      "json",
      "ts"
    ],
    "rootDir": "src",
    "testRegex": ".*\\.spec\\.ts$",
    "transform": {
      "^.+\\.(t|j)s$": "ts-jest"
    },
    "collectCoverageFrom": [
      "**/*.(t|j)s"
    ],
    "coverageDirectory": "../coverage",
    "testEnvironment": "node"
  }
} Running the app You can fire up the app in the dev environment using yarn start:dev Testing You can access the full . source code here Setting up a react project You can set up a simple react app using this command (or check out this ): detailed react documentation $ npx create-react-app nest-elastic-frontend Once your app is set up, open it in your favorite IDE, mine is VSCode. We will need to install as a dependency. If you prefer package manager, you will have to run but if you preferred yarn, . axios npm npm install axios yarn add axios We need to update three files public/index.html You need to add bootstrap CDN. (PS: I have removed the comments to reduce the length of the file). <!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8" />
    <link rel="icon" href="%PUBLIC_URL%/favicon.ico" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <meta name="theme-color" content="#000000" />
    <meta name="description" content="Web site created using create-react-app" />
    <link rel="apple-touch-icon" href="%PUBLIC_URL%/logo192.png" />
    <link rel="manifest" href="%PUBLIC_URL%/manifest.json" />
    <link
      href="//maxcdn.bootstrapcdn.com/bootstrap/4.1.1/css/bootstrap.min.css"
      rel="stylesheet"
      id="bootstrap-css"
    />
    <title>React App</title>
  </head>
  <body>
    <noscript>You need to enable JavaScript to run this app.</noscript>
    <div id="root"></div>
    <script src="//maxcdn.bootstrapcdn.com/bootstrap/4.1.1/js/bootstrap.min.js"></script>
    <script src="//cdnjs.cloudflare.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>
  </body>
</html> src/App.js import './App.css';
import axios from 'axios';
import { useState } from 'react';
const App = () => {
  const [searchResponse, setSearchResponse] = useState([]);
  const [totalValue, setTotalValue] = useState();

  const handleChange = async e => {
    const { data } = await axios.post('http://localhost:8000/movies/search', {
      data: {
        title: e.target.value,
      },
    });

    setSearchResponse(data.results);
    setTotalValue(data.total.value);
  };
  return (
    <div className='App'>
      <div className='container search-table'>
        <div className='search-box'>
          <div className='row'>
            <div className='col-md-3'>
              <h5>Search All Fields</h5>
            </div>
            <div className='col-md-9'>
              <input
                type='text'
                id='myInput'
                onChange={handleChange}
                className='form-control'
                placeholder='Search IMDB movies'></input>
            </div>
          </div>
        </div>
        <div className='search-list'>
          <h3>
            {totalValue ?? 0} {totalValue > 1 ? 'Records' : 'Record'} Found
          </h3>
          <table className='table' id='myTable'>
            <thead>
              <tr>
                <th>Title</th>
                <th>Overview</th>
                <th>Revenue:Budget ($)</th>
              </tr>
            </thead>
            <tbody>
              {searchResponse.map((res, idx) => (
                <tr key={idx}>
                  <td className='title'>{res.title}</td>
                  <td>
                    <p>{res.overview}</p>
                    <sub>"{res.tagline}"</sub>
                  </td>
                  <td>
                    <p>
                      <sub>
                        {res.revenue.toLocaleString()}:{res.budget.toLocaleString()}
                      </sub>
                    </p>
                  </td>
                </tr>
              ))}
            </tbody>
          </table>
        </div>
      </div>
    </div>
  );
};

export default App; Lastly, src/index.css body {
  margin: 0;
  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu',
    'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue', sans-serif;
  -webkit-font-smoothing: antialiased;
  -moz-osx-font-smoothing: grayscale;
}

code {
  font-family: source-code-pro, Menlo, Monaco, Consolas, 'Courier New', monospace;
}

.search-table {
  padding: 10%;
  margin-top: -6%;
}
.search-box {
  background: #c1c1c1;
  border: 1px solid #ababab;
  padding: 3%;
}
.search-box input:focus {
  box-shadow: none;
  border: 2px solid #eeeeee;
}
.search-list {
  background: #fff;
  border: 1px solid #ababab;
  border-top: none;
}
.search-list h3 {
  background: #eee;
  padding: 3%;
  margin-bottom: 0%;
}

.title {
  word-wrap: normal;
  width: 200px;
} Running your app Start your react app with or depending on your preferred package manager. yarn start npm start Testing your app Thanks for staying tuned! Here is the link to . the source code Also published . here

Create a Full Autocomplete Search Application with Elasticsearch, Kibana, NestJS and React

Content and data are at the core of every organization's business model; they hold the power to make or break an organization's future in the market. Leveraging content and data to your advantage can result in exponential growth within a short time frame, and managing them well, is therefore essential to success in today’s business environment. While there have been countless advancements within this domain, one of the most groundbreaking has been the development of the Headless CMS. A is a back-end content management system (CMS), built as a content repository that uses APIs to make content accessible. It’s “headless” because it’s decoupled from the front-end of the digital experience –  developers have separated the or front-end from the or back-end.  This is a departure from models in which the front and back-ends were combined into a simple monolithic system, placing limitations on an organization’s ability to manage and leverage the content across different applications. A headless CMS brings new options and possibilities for both engineers and users. Headless CMS head body Prior to the term “headless CMS” being coined, Directus pioneered the technology and is now disrupting the space. Founded in 2004 by Ben Hayes, the company has been at the technological forefront for nearly two decades. Since its inception, Directus has completed several major transitions. Rijk van Zanten joined Haynes in 2015 on the project and they dedicated themselves to democratizing data across the enterprise. Operating from the New York headquarters of the parent company, Monospace Inc., Directus has since become fully decentralized with all employees working remotely. Key competitors have included WordPress and Drupal. However, with the release of Directus 9 – a new version of the platform was built from the ground up in JavaScript with a focus on data and expanded use cases, including the ability to power SaaS offerings, internal tools, and data & analytics platforms – Directus has moved beyond competing with monolithic CMS vendors to establish itself as a pioneering Open Data Platform that can be used to manage anything in a SQL database. The rapid growth of Directus can be attributed to Haynes’s and Zanten’s passion for enabling technical and non-technical users to leverage content and data to support business initiatives and deliver data-driven digital projects to market rapidly and cost-effectively. The core team comprises roughly 50 people with 17 core members, including Haynes and Zanten. Since the beginning, Directus has been an open-source platform that’s free and accessible to anyone and will remain that way. Being open-source is one of the things that makes the Directus platform unique; thousands if not millions of developers and users from all parts of the world have contributed to the evolution of Directus, helping to shape the product roadmap and create an offering that meets the unique needs of developers building digital projects. In Q1, 2022, Directus launched a tiered cloud version of the platform, Directus Cloud, a performant and scalable data backbone for powering digital projects. Today, anyone can get up and running on Directus for free, through the Directus Community Cloud offering.

Powering the Future of Digital Project Development Through Data Democratization

The Terminal window, from back in the days when the computers were operated only by the command line or in the present when developing even the smallest project, we all use it. If this does not ring a bell yet, here is a about terminals aka. command-line interfaces: definition from Wikipedia A ( ) processes commands to a computer program in the form of lines of text. The program which handles the interface is called a or . command-line interface CLI command-line interpreter command-line processor These terminal interfaces are used by a lot of websites like Haskell, Hyper, even Codesandbox has a terminal (console). Let’s make one with for our website. ReactJs What we will build We will build a terminal emulator that accepts a set of predefined commands that we give it. You can or . view the code on GitHub see it in action here To build this terminal, we are using (CRA) to generate a new React application through our computer terminal. You can even see a terminal window animation on the CRA website in the section “Get started in seconds“. create-react-app First things first First things first, let’s create our React project using the (CRA) CLI. We will create an application with the template, to make our code better and avoid possible mistakes like adding two strings when we don’t want to. create-react-app Typescript I will name the application so, on my computer console, I will run the following code: terminal npx create-react-app terminal --template typescript After that, I will open the newly created folder in my code editor of choice, . terminal WebStorm Let’s clean up the files a little bit. Let’s delete the files , and from the folder. From the file , let’s remove everything that is within the with the className and also delete line number 2 and 3, with the logo import. Like so: logo.svg App.css App.test.tsx src/ App.tsx div App import React from 'react';

function App() {
  return (
    <div className="App">
      We will fill this section later
    </div>
  );
}

export default App; Creating the style and basic structure In the folder, let’s create another folder with the name , and inside that, create a file called one called . This will be our basic structure. src/ Terminal/ index.tsx terminal.css The terminal window is composed of two elements, the output, and the input. The output is where we will write the response, and the input is where we will write our commands. So, based on that, let’s create our terminal and add some style to it. In the , we will have the following code: index.tsx import './terminal.css';

export const Terminal = () => {
  return (
    <div className="terminal">
      <div className="terminal__line">A terminal line</div>
      <div className="terminal__prompt">
        <div className="terminal__prompt__label">alexandru.tasica:</div>
        <div className="terminal__prompt__input">
          <input type="text" />
        </div>
      </div>
    </div>
  );
}; Our style will be the following: terminal.css .terminal {
    height: 500px;
    overflow-y: auto;
    background-color: #3C3C3C;
    color: #C4C4C4;
    padding: 35px 45px;
    font-size: 14px;
    line-height: 1.42;
    font-family: 'IBM Plex Mono', Consolas, Menlo, Monaco, 'Courier New', Courier,
    monospace;
    text-shadow: 0 4px 4px rgba(0, 0, 0, 0.25);
}

.terminal__line {
    line-height: 2;
    white-space: pre-wrap;
}

.terminal__prompt {
    display: flex;
    align-items: center;
}

.terminal__prompt__label {
    flex: 0 0 auto;
    color: #F9EF00;
}

.terminal__prompt__input {
    flex: 1;
    margin-left: 1rem;
    display: flex;
    align-items: center;
    color: white;
}

.terminal__prompt__input input {
    flex: 1;
    width: 100%;
    background-color: transparent;
    color: white;
    border: 0;
    outline: none;
    font-size: 14px;
    line-height: 1.42;
    font-family: 'IBM Plex Mono', Consolas, Menlo, Monaco, 'Courier New', Courier,
    monospace;
} And also, let’s import that in our to view it in our browser: App.tsx import React from 'react';
import {Terminal} from "./Terminal";

function App() {
  return (
    <div className="App">
      <Terminal />
    </div>
  );
}

export default App; And the result is, 🥁 drums please: Good, so you’ve got where we are heading to. Basic state management Awesome! So we have the basic structure. Now we need to make users interact with it, keep our messages history and add new messages to the terminal. For that, we will write a custom hook called that will go hand-in-hand with our terminal. Let’s see the basic hook structure that we are going for: useTerminal import {useCallback, useEffect, useState} from 'react';
import {TerminalHistory, TerminalHistoryItem, TerminalPushToHistoryWithDelayProps} from "./types";


export const useTerminal = () => {
  const [terminalRef, setDomNode] = useState<HTMLDivElement>();
  const setTerminalRef = useCallback((node: HTMLDivElement) => setDomNode(node), []);

  const [history, setHistory] = useState<TerminalHistory>([]);

  /**
   * Scroll to the bottom of the terminal when window is resized
   */
  useEffect(() => {
    const windowResizeEvent = () => {
      terminalRef?.scrollTo({
        top: terminalRef?.scrollHeight ?? 99999,
        behavior: 'smooth',
      });
    };
    window.addEventListener('resize', windowResizeEvent);

    return () => {
      window.removeEventListener('resize', windowResizeEvent);
    };
  }, [terminalRef]);

  /**
   * Scroll to the bottom of the terminal on every new history item
   */
  useEffect(() => {
    terminalRef?.scrollTo({
      top: terminalRef?.scrollHeight ?? 99999,
      behavior: 'smooth',
    });
  }, [history, terminalRef]);

  const pushToHistory = useCallback((item: TerminalHistoryItem) => {
    setHistory((old) => [...old, item]);
  }, []);

  /**
   * Write text to terminal
   * @param content The text to be printed in the terminal
   * @param delay The delay in ms before the text is printed
   * @param executeBefore The function to be executed before the text is printed
   * @param executeAfter The function to be executed after the text is printed
   */
  const pushToHistoryWithDelay = useCallback(
    ({
       delay = 0,
       content,
     }: TerminalPushToHistoryWithDelayProps) =>
      new Promise((resolve) => {
        setTimeout(() => {
          pushToHistory(content);
          return resolve(content);
        }, delay);
      }),
    [pushToHistory]
  );

  /**
   * Reset the terminal window
   */
  const resetTerminal = useCallback(() => {
    setHistory([]);
  }, []);

  return {
    history,
    pushToHistory,
    pushToHistoryWithDelay,

    terminalRef,
    setTerminalRef,

    resetTerminal,
  };
}; And let’s also create a separate file that contains the type of the props and all the things we want to strongly type, like . Let’s create a file called with the definitions we have right now. Terminal History types.ts import {ReactNode} from "react";

export type TerminalHistoryItem = ReactNode | string;
export type TerminalHistory = TerminalHistoryItem[];
export type TerminalPushToHistoryWithDelayProps = {
  content: TerminalHistoryItem;
  delay?: number;
}; Now, after we have the types defined, let’s see a quick description of what does every function in our hook: The first state, will keep our reference to the terminal container. We will reference it later in our file. The first function is a helper function that sets the reference for that . terminalRef terminal/index.tsx div The first two will scroll done the terminal every time there is a new entry in our terminal history or every time the window is resized useEffects will push a new message to our terminal history pushToHistory will push the new message to our terminal history with a specific delay. We return a promise instead of resolving it as a function, so we can chain multiple pushes as an animation. pushToHistoryWithDelay Last, we have the which resets the terminal history. Works more like a function from the classic terminal. resetTerminal clear Awesome! Now that we have a way to store and push the messages, let’s go integrate this hook with structure. In the In the file, we will have some props that will be connected with the terminal history and also will handle the focus on our terminal input prompt. Terminal/index.tsx import './terminal.css';
import {ForwardedRef, forwardRef, useCallback, useEffect, useRef} from "react";
import {TerminalHistory, TerminalHistoryItem} from "./types";

export type TerminalProps = {
  history: TerminalHistory;
  promptLabel?: TerminalHistoryItem;
};

export const Terminal = forwardRef(
  (props: TerminalProps, ref: ForwardedRef<HTMLDivElement>) => {
    const {
      history = [],
      promptLabel = '>',
    } = props;

    /**
     * Focus on the input whenever we render the terminal or click in the terminal
     */
    const inputRef = useRef<HTMLInputElement>();
    useEffect(() => {
      inputRef.current?.focus();
    });

    const focusInput = useCallback(() => {
      inputRef.current?.focus();
    }, []);

    return (
    <div className="terminal" ref={ref} onClick={focusInput}>
      {history.map((line, index) => (
        <div className="terminal__line" key={`terminal-line-${index}-${line}`}>
          {line}
        </div>
      ))}
      <div className="terminal__prompt">
        <div className="terminal__prompt__label">{promptLabel}</div>
        <div className="terminal__prompt__input">
          <input
            type="text"
            // @ts-ignore
            ref={inputRef}
          />
        </div>
      </div>
    </div>
  );
}); And not, let’s connect the dots and push something to the terminal. Because we accept any as a line, we can push any HTML we want. ReactNode Our will be the wrapper, this is where all the action will happen. Here we will set the messages we want to show. Here is a working example: App.tsx import React, {useEffect} from 'react';
import {Terminal} from "./Terminal";
import {useTerminal} from "./Terminal/hooks";

function App() {
  const {
    history,
    pushToHistory,
    setTerminalRef,
    resetTerminal,
  } = useTerminal();


  useEffect(() => {
    resetTerminal();

    pushToHistory(<>
        <div><strong>Welcome!</strong> to the terminal.</div>
        <div style={{fontSize: 20}}>It contains <span style={{color: 'yellow'}}><strong>HTML</strong></span>. Awesome, right?</div>
      </>
    );
  }, []);

  return (
    <div className="App">
      <Terminal
        history={history}
        ref={setTerminalRef}
        promptLabel={<>Write something awesome:</>}
      />
    </div>
  );
}

export default App; And, the result so far is: On mount, we just push whatever we want, like that cool big yellow HTML text. Implementing commands Awesome! You made it almost to the end. Now let’s add the ability for the user to interact with our terminal, in writing. In our will add the option to update the input, and also the commands that every word will execute. These are the most important things in a terminal, right? Terminal/index.tsx Let’s handle the user input in the file, and listen there when the user presses the key. After that, we execute the function that he wants. Terminal/index.tsx Enter The the file will transform into: Terminal/index.tsx import './terminal.css';
import {ForwardedRef, forwardRef, useCallback, useEffect, useRef, useState} from "react";
import {TerminalProps} from "./types";

export const Terminal = forwardRef(
  (props: TerminalProps, ref: ForwardedRef<HTMLDivElement>) => {
    const {
      history = [],
      promptLabel = '>',

      commands = {},
    } = props;

    const inputRef = useRef<HTMLInputElement>();
    const [input, setInputValue] = useState<string>('');

    /**
     * Focus on the input whenever we render the terminal or click in the terminal
     */
    useEffect(() => {
      inputRef.current?.focus();
    });

    const focusInput = useCallback(() => {
      inputRef.current?.focus();
    }, []);


    /**
     * When user types something, we update the input value
     */
    const handleInputChange = useCallback(
      (e: React.ChangeEvent<HTMLInputElement>) => {
        setInputValue(e.target.value);
      },
      []
    );

    /**
     * When user presses enter, we execute the command
     */
    const handleInputKeyDown = useCallback(
      (e: React.KeyboardEvent<HTMLInputElement>) => {
        if (e.key === 'Enter') {
          const commandToExecute = commands?.[input.toLowerCase()];
          if (commandToExecute) {
            commandToExecute?.();
          }
          setInputValue('');
        }
      },
      [commands, input]
    );

    return (
    <div className="terminal" ref={ref} onClick={focusInput}>
      {history.map((line, index) => (
        <div className="terminal__line" key={`terminal-line-${index}-${line}`}>
          {line}
        </div>
      ))}
      <div className="terminal__prompt">
        <div className="terminal__prompt__label">{promptLabel}</div>
        <div className="terminal__prompt__input">
          <input
            type="text"
            value={input}
            onKeyDown={handleInputKeyDown}
            onChange={handleInputChange}
            // @ts-ignore
            ref={inputRef}
          />
        </div>
      </div>
    </div>
  );
}); As you can see, we have moved the type defined here, into the separate file we created called . Let’s explore that file and see what new stuff we defined. types.ts import {ReactNode} from "react";

export type TerminalHistoryItem = ReactNode | string;
export type TerminalHistory = TerminalHistoryItem[];
export type TerminalPushToHistoryWithDelayProps = {
  content: TerminalHistoryItem;
  delay?: number;
};


export type TerminalCommands = {
  [command: string]: () => void;
};

export type TerminalProps = {
  history: TerminalHistory;
  promptLabel?: TerminalHistoryItem;
  commands: TerminalCommands;
}; Good, now that we can execute commands from the terminal, let’s define some in the . We will create only two simple ones, but you let your imagination run wild! App.tsx import React, {useEffect, useMemo} from 'react';
import {Terminal} from "./Terminal";
import {useTerminal} from "./Terminal/hooks";

function App() {
  const {
    history,
    pushToHistory,
    setTerminalRef,
    resetTerminal,
  } = useTerminal();


  useEffect(() => {
    resetTerminal();

    pushToHistory(<>
        <div><strong>Welcome!</strong> to the terminal.</div>
        <div style={{fontSize: 20}}>It contains <span style={{color: 'yellow'}}><strong>HTML</strong></span>. Awesome, right?</div>
        <br/>
        <div>You can write: start or alert , to execute some commands.</div>
      </>
    );
  }, []);

  const commands = useMemo(() => ({
    'start': async () => {
      await pushToHistory(<>
          <div>
            <strong>Starting</strong> the server... <span style={{color: 'green'}}>Done</span>
          </div>
        </>);
    },
    'alert': async () => {
      alert('Hello!');
      await pushToHistory(<>
          <div>
            <strong>Alert</strong>
            <span style={{color: 'orange', marginLeft: 10}}>
              <strong>Shown in the browser</strong>
            </span>
          </div>
        </>);
    },
  }), [pushToHistory]);

  return (
    <div className="App">
      <Terminal
        history={history}
        ref={setTerminalRef}
        promptLabel={<>Write something awesome:</>}
        commands={commands}
      />
    </div>
  );
}

export default App; The constant defines the command that should be typed by the user. So if the user types and hits enter, he will see the text “ the server… Done“. commands start Starting What we’ve built Thanks for reaching the end, you are awesome! Here is what we’ve built together, hopefully, it will be helpful for your website or a client’s website. What’s next? What’s next you ask? The terminal right now is pretty simple. You don’t see the previously typed commands. If the user types an incorrect command, he will see nothing. And, of course, animations! See you in part two for these new features. Until then, you can or . view the code on GitHub see it in action here

Creating a Terminal Emulator in React

Right in the Feels When it comes down to it, you have to love what you do. As software engineers, we spend a huge amount of time writing code. Granted, the further you progress in your career the less code you’ll actually write, but even for the more senior staff, it’s a significant part of the job. Personally, I find a huge difference in my programming stamina when I have great tools and themes in place. Having the right tools configured properly for your job can make a huge difference. Here are some of the tools/settings/styles that I’ve picked up along the way that I think will make your life more enjoyable. Sometimes all it takes is a fresh font to become inspired. Try something new! 1. Solid IDE and Theme If the main focus of your role is to produce high-quality code, you are probably using an IDE. It’s easy to just download whatever one is recommended to you, or that you’re the most familiar with, and stick with the same settings you’ve used for years. But sometimes change can be inspirational. I’m not saying my setup is better than anyone else’s but I find it simultaneously relaxing and invigorating, which makes writing code more enjoyable. : Editor Visual Studio Code Font: Cascadia Code Color scheme: Solarized Dark , , , Notable Extensions: Disable Ligatures Projects Indent Rainbow Prettier Settings for Font Ligatures: {
    "workbench.colorTheme": "Solarized Dark",
    "editor.tokenColorCustomizations": {
        "textMateRules": [
            {
                "scope": [
                    //following will be in italic (=FlottFlott)
                    "comment",
                    "entity.name.type.class", //class names
                    "keyword", //import, export, return…
                    "constant", //String, Number, Boolean…, this, super
                    "storage.modifier", //static keyword
                    "storage.type.class.js", //class keyword
                ],
                "settings": {
                    "fontStyle": "italic"
                }
            },
            {
                "scope": [
                    //following will be excluded from italics (VSCode has some defaults for italics)
                    "invalid",
                    "keyword.operator",
                    "constant.numeric.css",
                    "keyword.other.unit.px.css",
                    "constant.numeric.decimal.js",
                    "constant.numeric.json"
                ],
                "settings": {
                    "fontStyle": ""
                }
            }
        ]
    },
    "editor.fontFamily": "'Cascadia Code', Menlo, Monaco, 'Courier New', monospace",
    "editor.fontWeight": "350",
    "editor.fontLigatures": "'calt', 'ss01', 'ss02', 'ss03', 'ss04', 'ss05', 'ss06', 'zero', 'onum'",
    "disableLigatures.mode": "Line"
} VSCode provides a huge amount of flexibility without compromising simplicity. The Cascadia Code font with ligatures creates really nice cursive characters and other signage that makes the code more fun to read. Lastly, the extensive library of VSCode provides so much additional functionality that finding a few new extensions makes it feel like an entirely new editor. 2. Flexible Command Line Prompt There are a lot of options out there, depending on your platform. Personally, I develop on a MacBook so my suggestion here is iTerm2.  I’ve chosen this program for two major reasons. First is the saved-window-groups feature that allows you to split your terminal into multiple panes, then save that as a “window group” to quickly recreate it. The second is the ability to create profiles. Each profile has its own color scheme and you can auto-run the lines of code at the start of the terminal session (without having to edit your zsh/bash profile). Combined, this creates a really powerful environment. At the beginning of every day I open up iTerm, and it defaults to my favorite window group which has 3 panes. One auto-starts a sync that I have to have running all day. The second opens up some internal documentation that I’m constantly reviewing. The third updates all of my local packages then start in my local code directory, ready for work. Just by opening this app, I now have 3 simple (yet important) tasks completed and ready to go without another thought. Last, and yet probably just as important, these terminal profiles all have their own color scheme. This makes it easy to differentiate between the panels, makes them easy to look at, and is fun to use. 3. Configured Shell Environment Now that you’ve chosen and configured your terminal application, you’ll actually have to use it. For this, you’ll want to take some time to learn about the shell environment you have to work in. Again, I’m on a Mac so it defaults to zsh, which isn’t a terrible choice. For a long time, I would manually swap this for bash, but then I discovered and I never swapped again.  Whether you have a very in-depth bash file, or you use something like Oh-My-ZSH, the point here is that you want to make massive quality-of-life upgrades to your shell environment so that when you do have to work in it, it’s a dream. Oh-My-ZSH, .profile Aside from making your terminal look way cooler with some awesome themes, you can use plugins to add a ton of additional functionality that you didn’t know you needed. My favorite upgrade is one of the simplest ones, a theme that interfaces with git so you can tell exactly what repo and branch you’re in, at all times. 4. Non-GUI Text Editor While we’re on the topic of terminals, there’s one last point to consider. You’re going to need a text editor that you’re comfortable with. Again, you’re going to spend some time in here doing…who knows what, so it might as well be something functional, with lots of awesome features and customizable options. Personally, I like and have for a long time. Vim’s themes are really well done, and the UI is slim and non-intrusive making it easy to use, once you’re familiar with the keyboard shortcuts. But further, by finding a good .vimrc file (or making one yourself) so you can ensure the editing environment is customized to your needs. Vim Things like how far indented each nested line of code should be or whether it should be indented with tabs or spaces are highly customizable. There’s also a wealth of plugins to consider that can help with code completion and syntax highlighting. I usually start with this “ ” file and then customize it as needed. The Ultimate Vimrc 5. Browser Whether you’re a web developer and need a solid suite of testing tools or an iOS developer with testing and validation built right into your IDE, let’s just agree on one thing. We all need access to . No matter what you do, you need a good, trustworthy browser. In every role, I’ve had two major considerations to make when picking which browser will be my system default. First, what is the recommended browser by my organization (this does matter)? Second, what browser is going to best fit my needs? Stack Overflow Currently, the go-to is . Chrome has a large library of extensions that work really well with my other tools allowing me to debug with speed and agility. It also interfaces nicely with my organization’s policies and online platforms that I use daily. Google Chrome Once you choose a browser, make it work for you. Migrate your bookmarks, organize them, and take the time to browse the extensions or plugin libraries. Don’t forget that you’re likely to spend most of your day here, make sure it works for you. , , Notable extensions: Xdebug Helper React Developer Tools Redux DevTools 6. Productivity Tools At this point, you should have the tools you need to perform your daily tasks. So what’s left? Well, there are always little shortcuts that can help you be more productive. Github has a desktop application that you can use if you don’t love working on the command line. There’s a whole world out there of note-taking applications that can make your meetings a thing of wonder. There are database applications aplenty. Take some time to document all of your daily tasks and requirements and see what tools are out there that make your life easier. My favorite productivity tool is a lesser-known one named . Dash Dash has two major sections too, both very useful. First, it allows you to download a huge amount of document sets for offline viewing. If your job requires you to do any sort of traveling or, if you just like to work from not-home or not-office occasionally, this can be a huge life-saver. What do you do when you can’t visit stack overflow or jump over to your favorite framework’s documentation page? Open up dash and it’s all right there. Second, it allows you to store code snippets for re-use. I’ve used this for the complicated or detailed commands that I have to run consistently. You can even activate a “listener” that will auto-replace your text when you type. So instead of having to type docker-compose exec app bash Over and over, you can create a snippet titled dc-exec, and when Dash recognizes you're typing that out, it’ll auto-replace it with the required command. The best part is that these snippet files can be backed up and transferred so you don’t have to recreate them every time you set up a new machine. Go Conquer the World! Well, you have it there, folks. You’ve basically walked through a day in my life as a developer. With a good IDE, font, theme, and a solid set of helper tools at your disposal you can achieve absolutely anything.

Stories, News & Mentions about MOCOSPACE

Mocospace’s Stories on HackerNoon

Mocospace's News & Mentions