WorkSpan is the #1 co-sell management network that empowers companies to turbocharge and scale their co-sell revenue growth

WorkSpan

Ethical hacking is a fascinating and important field in cybersecurity, where skilled professionals use their hacking skills to identify and fix security vulnerabilities in systems, networks, and applications. Here's a detailed guide to get you started on the path of ethical hacking: Introduction to Ethical Hacking Definition and Purpose: Ethical hacking involves legally breaking into computers and devices to test an organization's defenses. It's also known as penetration testing or white-hat hacking. Key Differences from Malicious Hacking: Unlike black-hat hackers, ethical hackers have permission to breach systems and do so to improve security, not to harm or steal. Getting Started with Ethical Hacking Basic Requirements: Fundamental understanding of networking, systems, and web technologies. Proficiency in programming languages like Python, JavaScript, and SQL. Familiarity with operating systems, especially Linux. Always have written permission before testing a network or system. Legal Considerations: Learning Resources Look for reputable books and online courses covering ethical hacking basics, tools, and techniques. Books and Online Courses: Consider obtaining certifications like Certified Ethical Hacker (CEH) or Offensive Security Certified Professional (OSCP). Certifications: Common Tools and Techniques Tools like Nmap and Shodan help in gathering information about the target system. Reconnaissance Tools: Tools like Nessus and OpenVAS scan for known vulnerabilities. Vulnerability Analysis: Metasploit is widely used for developing and executing exploit code against a remote target machine. Exploitation Tools: Tools like Burp Suite and OWASP ZAP are essential for testing web applications. Web Application Hacking: Setting Up a Lab Use virtual machines (VMs) to create a safe environment for hacking practice. Virtual Environment: Use deliberately vulnerable applications and systems like OWASP WebGoat or Metasploitable for practice. Practice Targets: Ethical Hacking Methodology Define the scope and goals of a test, including the systems to be addressed and the testing methods to be used. Planning: Gather information to understand how the target works and its potential vulnerabilities. Reconnaissance: Use tools to identify live hosts, open ports, and services running on machines. Scanning: Gaining Access: Exploit vulnerabilities to enter the system or network. Ensure a stable connection to gather as much data as needed for the assessment. Maintaining Access: Analyze the data gathered and report the findings with recommendations for security improvements. Analysis and Reporting: Ethical Considerations Avoid accessing or disclosing personal or sensitive information unless absolutely necessary for the test. Respect Privacy: Clearly communicate findings and suggest remediations to the organization. Transparency and Reporting: Staying Updated The field of cybersecurity is always evolving, so it's crucial to stay updated with the latest developments, vulnerabilities, and tools. Continuous Learning: Conclusion Ethical hacking is a critical component of cybersecurity. By understanding and implementing these practices, you can significantly contribute to the security and integrity of information systems.

A Glimpse into an Ethical Hacker's High-Tech Workspace

এথিক্যাল হ্যাকারের হাই-টেক ওয়ার্কস্পেসের একটি ঝলক

Ein Einblick in den High-Tech-Arbeitsbereich eines ethischen Hackers

Un vistazo al espacio de trabajo de alta tecnología de un hacker ético

Un aperçu de l'espace de travail high-tech d'un hacker éthique

एथिकल हैकर के हाई-टेक कार्यक्षेत्र की एक झलक

エシカルハッカーのハイテクワークスペースを垣間見る

윤리적인 해커의 하이테크 작업 공간 엿보기

Um vislumbre do espaço de trabalho de alta tecnologia de um hacker ético

Взгляд на высокотехнологичное рабочее пространство этичного хакера

Etik Bir Hackerın Yüksek Teknolojili Çalışma Alanına Kısa Bir Bakış

Cái nhìn thoáng qua về không gian làm việc công nghệ cao của hacker có đạo đức

道德黑客的高科技工作空间一瞥

BOSTON, Massachusetts, November 28th, 2023/Cyberwire/--A severe design flaw in Google Workspace's domain-wide delegation feature discovered by threat hunting experts from , can allow attackers to misuse existing delegations, enabling privilege escalation and unauthorized access to Workspace APIs without Super Admin privileges. Hunters’ Team Axon Such exploitation could result in theft of emails from Gmail, data exfiltration from Google Drive, or other unauthorized actions within Google Workspace APIs on all of the identities in the target domain. Hunters has responsibly disclosed this to Google and worked closely with them prior to publishing this research. Domain-wide delegation permits a comprehensive delegation between Google Cloud Platform (GCP) identity objects and Google Workspace applications. In other words, it enables GCP identities to execute tasks on Google SaaS applications, such as Gmail, Google Calendar, Google Drive, and more, on behalf of other Workspace users. The design flaw, which the team at Hunters has dubbed “DeleFriend,” allows potential attackers to manipulate existing delegations in GCP and Google Workspace without possessing the high-privilege Super Admin role on Workspace, which is essential for creating new delegations. Instead, with less privileged access to a target GCP project, they can create numerous JSON web tokens (JWTs) composed of different OAuth scopes, aiming to pinpoint successful combinations of private key pairs and authorized OAuth scopes which indicate that the service account has domain-wide delegation enabled. The root cause lies in the fact that the domain delegation configuration is determined by the service account resource identifier (OAuth ID), and not the specific private keys associated with the service account identity object. Additionally, no restrictions for fuzzing of JWT combinations were implemented on the API level, which does not restrict the option of enumerating numerous options for finding and taking over existing delegations. This flaw poses a special risk due to potential impact described above and is amplified by the following: Long Life: By default, GCP Service account keys are created without an expiry date. This feature makes them ideal for establishing backdoors and ensuring long-term persistence. Easy to hide: The creation of new service account keys for existing IAMs or, alternatively, the setting of a delegation rule within the API authorization page is easy to conceal. This is because these pages typically host a wide array of legitimate entries, which are not examined thoroughly enough. Awareness: IT and Security departments may not always be cognizant of the domain-wide delegation feature. They might especially be unaware of its potential for malicious abuse. Hard to detect: Since delegated API calls are created on behalf of the target identity, the API calls will be logged with the victim details in the corresponding GWS audit logs. This makes it challenging to identify such activities. “The potential consequences of malicious actors misusing domain-wide delegation are severe. Instead of affecting just a single identity, as with individual OAuth consent, exploiting DWD with existing delegation can impact every identity within the Workspace domain,” says Yonatan Khanashvili of Hunters’ Team Axon. The range of possible actions varies based on the OAuth scopes of the delegation. For instance, email theft from Gmail, data exfiltration from the drive, or monitor meetings from Google Calendar. In order to execute the attack method, a particular GCP permission is needed on the target Service Accounts. However, Hunters observed that such permission is not an uncommon practice in organizations making this attack technique highly prevalent in organizations that don’t maintain a security posture in their GCP resources. “By adhering to best practices, and managing permissions and resources smartly, organizations can dramatically minimize the impact of the attack method” Khanashvili continued. Hunters has created a (full details are included in the full research) to assist organizations in detecting DWD misconfigurations, increasing awareness, and reducing DeleFriend’s exploitation risks. proof-of-concept tool Using this tool, red teams, pen testers, and security researchers can simulate attacks and locate vulnerable attack paths of GCP IAM users to existing delegations in their GCP Projects to evaluate (and then improve) the security risk and posture of their Workspace and GCP environments. Hunters’ Team Axon has also compiled that lays out exactly how the vulnerability works as well as recommendations for thorough threat hunting, detection techniques, and best practices for countering domain-wide delegation attacks. comprehensive research Hunters responsibly reported DeleFriend to Google as part of Google’s “Bug Hunters” program in August, and are collaborating closely with Google's security and product teams to explore appropriate mitigation strategies. Currently, Google has yet to resolve the design flaw. Read the full research , and follow Hunters’ . here Team Axon on Twitter About Hunters delivers a Security Operations Center (SOC) Platform that reduces risk, complexity, and cost for security teams. A SIEM alternative, Hunters SOC Platform provides data ingestion, built-in and always up-to-date threat detection, and automated correlation and investigation capabilities, minimizing the time to understand and respond to real threats. Hunters Organizations like Booking.com, ChargePoint, Yext, Upwork and Cimpress leverage Hunters SOC Platform to empower their security teams. Hunters is backed by leading VCs and strategic investors including Stripes, YL Ventures, DTCP, Cisco Investments, Bessemer Venture Partners, U.S. Venture Partners (USVP), Microsoft’s venture fund M12, Blumberg Capital, Snowflake, Databricks, and Okta. Contact Yael Macias yael@hunters.security This story was distributed as a release by Cyberwire under HackerNoon’s Business Blogging Program. Learn more about the program . here

Hunters Team Axon Discovers Design Flaw That Could Leave Google Workspace Vulnerable For Takeover

হান্টার্স টিম অ্যাক্সন ডিজাইনের ত্রুটি আবিষ্কার করেছে যা টেকওভারের জন্য Google ওয়ার্কস্পেসকে ঝুঁকিপূর্ণ ছেড়ে দিতে পারে

Das Hunters-Team Axon entdeckt einen Designfehler, der Google Workspace anfällig für eine Übernahme machen könnte

Hunters Team Axon descubre un defecto de diseño que podría dejar a Google Workspace vulnerable a la adquisición

L'équipe Hunters Axon découvre une faille de conception qui pourrait rendre Google Workspace vulnérable au rachat

हंटर्स टीम एक्सॉन ने डिज़ाइन दोष का पता लगाया है जो Google वर्कस्पेस को अधिग्रहण के लिए असुरक्षित बना सकता है

Hunters Team Axon が Google Workspace を乗っ取りの危険にさらす可能性のある設計上の欠陥を発見

Hunters Team Axon, Google Workspace를 인수에 취약하게 만들 수 있는 설계 결함 발견

A equipe de Hunters Axon descobre uma falha de design que pode deixar o Google Workspace vulnerável para aquisição

Команда охотников Axon обнаружила недостаток в конструкции, который может сделать Google Workspace уязвимым для захвата

Hunters Team Axon, Google Workspace'i Devralınmaya Karşı Savunmasız Bırakabilecek Tasarım Kusurunu Keşfetti

Nhóm Hunters Axon phát hiện ra lỗ hổng thiết kế có thể khiến Google Workspace dễ bị tiếp quản

Hunters Team Axon 发现设计缺陷，可能导致 Google Workspace 容易被接管

A monorepo is a repository containing multiple related resources managed from an individual repository. Using , we can build dynamic component libraries that numerous applications can consume, all retained in one version-controlled repository. NPM workspaces Introduction Monorepo's have been gaining traction over the years. Having worked with them for over a year in production environments, I can say one thing: ! they beat git submodules A typical monorepo will contain multiple packages and projects that are closely related. We can work more efficiently using a monorepo in a way that allows us to move away from: initializing git submodules (a repo within a repo) linking local packages from other locations on the disk that must be updated and installed. NPM supports , which effectively allows for a monorepo structure. You'll need to use NPM v7 and above to set up a Recently, I embarked on building a suite of components for a NextJS project. I wanted to ensure that I could actively develop components (facilitated by Storybook) so that my NextJS projects could consume those components. workspaces workspace. Historically, have always supported a folder. However, NextJS restricts this to the application itself. I aim to treat my component library like any other 3rd-party library I'd want to import into my projects. An architecture of this manner is easily achievable using a mono repo. NextJS projects components Initialise Project Structure Our first step is to set up a project structure supporting a monorepo. Create a folder where your monorepo can live: mkdir my-monorepo && cd my-monorepo Great. Our next step is to create a file. We can bootstrap one quickly by running the following: package.json npm init -y That should produce the following output: {
  "name": "my-monorepo",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
} Let's add some items to our before installing dependencies. We'll need to add a key. Doing so informs NPM where our projects and packages sit. package.json workspaces NPM comes with a nifty command for adding workspaces; run the below commands and follow the instruction wizard that each command outputs: npm init -w ./packages/component-library
npm init -w ./projects/monorepo-site Executing the above will run for you as well. npm install At this point, we will see our first fundamental differences between a traditional repo and a monorepo: A exists in the root and within every "workspace." You may notice that there is only one occurrence of and Now, all workspace dependencies get managed from the root folder. package.json node_modules package-lock.json. Next up, we'll look into how to install workspace-specific dependencies. Install dependencies When installing package or project dependencies, we can still leverage - however, this needs to be run from the root folder and requires that we pass a flag to the command. Let's run through . npm install -w installing NextJS npm install --save next react react-dom -w monorepo-site Run the command above from the of your project folder, where and the can be found. The only thing to call out here is that the value passed to must match the field of one of your or package.json. In this example, the field of is root node_modules package-lock.json -w name project packages name projects/monorepo-site/package.json monorepo-site. If all was successful, you should see the dependencies added to projects/monorepo-site/package.json. "dependencies": {
    "next": "^13.0.6",
    "react": "^18.2.0",
    "react-dom": "^18.2.0"
} Repeat this process for any necessary dependencies in as well. packages/component-library Setup Components and StoryBook Please note that this is not a tutorial on how to get set up with Storybook. Let's take some steps to get Storybook set up correctly. We'll also create a dummy component to verify that our setup works. As StoryBook isn't a dependency of either or we can install it in the root of our monorepo: packages projects, npm install --save-dev @storybook/react @storybook/manager-webpack5 @storybook/builder-webpack5 @storybook/addon-postcss Let's also add the build commands to the root monorepo package.json: "storybook": "start-storybook -p 6006",
"build-storybook": "build-storybook" Next, we'll need to create the folder; let's do this and add it to the root of the monorepo. You'll want to add two files to this folder: .storybook main.js preview.js is where we configure StoryBook's settings: main.js module.exports = {
    "stories": [
        "../packages/component-library/**/*.stories.jsx",
    ],
    "addons": [
        {
            name: '@storybook/addon-postcss',
            options: {
                styleLoaderOptions: {},
                cssLoaderOptions: {
                    modules: true,
                    sourceMap: true,
                    importLoaders: 1,
                },
                postcssLoaderOptions: {
                    implementation: require('postcss'),
                },
            },
        }
    ],
    "framework": "@storybook/react",
    "core": {
        "builder": "@storybook/builder-webpack5"
    }
} In our file above - we tell StoryBook where to look for component stories. We also include the plugin that supports PostCSS. The extra options you see listed above enabled PostCSS Modules. The last two keys: and allow us to configure StoryBook to use Webpack v5. main.js @storybook/addon-postcss framework core, In add the following: preview.js, export const decorators = [
    (Story, context) => {
        return (
            <div style={{ padding: '1rem', display: 'flex', justifyContent: 'center' }}>
                <div>
                    <Story {...context} />
                </div>
            </div>
        );
    }
]; The file allows us to customize the appearance of stories without affecting the component logic itself. Hence, the name "decorator". I've just added some basic styling here to center the button. preview.js Next, we need to flesh out our component. In add a new folder called ; in that folder, add the following files: Button package/component-library, Button Button.module.css - handles the styling of the button Button.stories.jsx - handles the button story Button.jsx - the button component itself You can find the contents of these files in the repo. Great, we need to see if we can import our component into NextJS. Setup a NextJS project We need to return to NextJS quickly to tie everything together meaningfully. First, add a folder to the and the scripts needed in to build NextJS. pages NextJS site package.json To add the scripts, go to and replace the current field with: projects/monorepo-site/package.json scripts "scripts": {
	"dev": "next dev",
	"build": "next build",
	"start": "next start",
	"lint": "next lint"
} In the folder, add an file with the following contents: pages index.js const Home = () => {
	return (
		<main>
			<h1>Hello! This is a NextJS + StoryBook Monorepo</h1>
		</main>
	)
}

export default Home Add the Component to NextJS Now, it's time to import our component into NextJS. Let's import the button into : projects/monorepo-site/pages/index.js import Button from '../../../packages/component-library/Button/Button.jsx' When you run , you'll likely run into an error. NextJS does not transpile ES6 JavaScript from or any other local folder outside its reach. npm run dev node_modules To get around this problem, configure a property in called : next.config.js transpileModules export const nextConfig = {
	transpileModules: ['component-library']
} Note that the name, is passed, not the path to the folder on the disk. You'll need to restart your dev server. workspace component-library, Your custom Button component now lives in NextJS and StoryBook and can be iterated upon and tracked in the repo! You may run into trouble with NextJS asking for React v18 if you use NextJS 13. This tutorial was written using NextJS v12 and React v17.0.2 Additional Scripts for Convenience To run our build commands, we'd have to into every or . Doing so can be time-consuming, so let's add the following to the found in the root: cd project package scripts package.json "scripts": {
	"build": "npm run build --workspaces --if-present",
	"dev:monorepo-site": "npm run dev -w monorepo-site",
} Let's run through these two commands as they differ slightly. Running in the root will allow us to fire off individual scripts in all workspaces. If the task isn't in a or package.json, it will simply skip it. npm run build build build package project If, at some point, this particular example scaled to have three production sites, all with a command, we could run from the root, and for each workspace, the build task will execute. Pretty nifty! build npm run build is slightly different - this command targets one workspace and fires off the defined within that workspace (as long as it exists). Doing so allows us to spin up the server for from the root without navigating to the folder. npm run dev:monorepo-site script dev monorepo-site Conclusion Let's review where we're at: We initialized a monorepo structure using in NPM workspaces Set up a component library and production site with StoryBook and NextJS. Added scripts that will make our developer experience more accessible to manage. All our dependencies get managed from the top level, and we do not have to pull in other repos or git submodules. At this point, we could easily add a new site project or extend our component library. We could also add other that may deal with custom server functionality, CMS integrations, or API support. The possibilities are endless. Now it's time for you to try! packages Also published . here

Mastering Monorepos: Organizing Component NextJS Libraries & Projects with NPM Workspaces

Monorepos lets you manage multiple repositories into one single repository but managing and publishing them can be very tedious as the repositories grow. Lerna is a powerful tool that can be used to manage and publish monorepos in Javascript/Typescript projects. Lerna is a fast, modern build system for managing and publishing multiple JavaScript/TypeScript packages from the same repository. In this article, we will see how we can set up a monorepo with Lerna and Npm workspaces. If you are interested in setting up a monorepo with Vite, Pnpm, and Typescript you can check out my previous blog . here Why use Lerna? To use monorepos well, you need a good monorepo tool, and Lerna is exactly that. Lerna is fast, widely used, and battle tested. Monorepos can have tens if not hundreds of packages, and managing all of them together can become very difficult. Lerna can rescue us in this situation by doing the heavy lifting of managing the tasks in different packages, versioning, code deployment, etc. Lerna has some great in-built features which make managing monorepos surprisingly easier. : Lerna gives us an out-of-the-box solution to run tasks inside multiple packages together using command. For example, Let's say you have 3 packages inside your monorepo and you want to run the script for all of them, with Lerna all you have to do is just run command from the root of your project and it will run the script inside each of your packages (You must have defined the script in package.json for all the projects respectively in order to make this work properly). Running tasks within multiple packages lerna run test npx lerna run test test test : When the workspace becomes very huge it is common for a new developer to face difficulty in understanding the hierarchy of the workspace and understand how different packages are linked together. Lerna uses to help visualize the workspace graph. Simply run and it will launch a project visualization graph on your browser. Visualize the workspace Nx npx nx graph You can check the complete list of Lerna features . here Who uses Lerna? Lerna is being used by many different teams including but not limited to: Jest Create React App Nx NestJS Project Setup Prerequisites To follow along, you must have installed in your system which I am assuming that you would already have. Other than that, some basic knowledge of Javascript/Typescript and React will help in understanding the code that we are going to write. Node Project Overview For the sake of this article, our monorepo will have two packages: : A shared library that can be used by multiple packages. common : A basic React app that will consume the package and will render the components on UI. client common Getting Started Let's start off by creating a new directory at your desired location. mkdir npm-lerna-monorepo Then, move inside your newly created directory and initialize a Lerna workspace. # npm-lerna-monorepo
npx lerna init This command will do the following things: Create a file if it is not already present and add as a dev dependency. package.json lerna Create and configure a new file. lerna.json Configure npm workspaces inside . package.json Create a directory that will contain all our monorepo packages. packages ├── lerna.json
├── .gitignore
├── package.json
└── packages Now, in order to use Typescript in our project, we need to install a few dependencies at the root level. npm i typescript @types/node -D Once the above dependencies are installed, create a common file that will be extended by all the other packages of our app. tsconfig.json {
  "compilerOptions": {
    "module": "commonjs",
    "declaration": false,
    "noImplicitAny": false,
    "removeComments": true,
    "noLib": false,
    "emitDecoratorMetadata": true,
    "experimentalDecorators": true,
    "target": "es6",
    "allowSyntheticDefaultImports": true,
    "sourceMap": true,
    "moduleResolution": "node",
    "lib": ["es6"]
  },
  "exclude": ["node_modules"]
} Now we can start creating our packages, to do that let's go inside the directory and create the package first. packages common npm create vite@latest common --template react-ts We should now have a package inside our directory, now let's move inside the directory and run to install all the required dependencies. common packages common npm install # npm-lerna-monorepo/packages/common
npm install In order to use the base Typescript configuration that we've defined at the root level, we need to add the following snippet at the beginning of our inside the common package. tsconfig.json // npm-lerna-monorepo/packages/common/tsconfig.json
{
  "extends": "../../tsconfig.json",
  ...
} We will now go ahead and create a Button component and will export it so that it can be used by the other packages in our monorepo. // npm-lerna-monorepo/packages/common/src/components/Button.tsx

interface ButtonProps {
    buttonText: string;
}

const Button = ({ buttonText }: ButtonProps) => {
    return (
        <button>{buttonText}</button>
    )
}

export default Button; Now export this Button component from file which will be our entry point. main.tsx // npm-lerna-monorepo/packages/common/src/main.tsx
import Button from "./components/Button"

export { Button } We will set as our entry point by setting the property in main.tsx main package.json Also, as per the common workspace naming convention of monorepos we'll change the name of the package to common @npm-lerna-monorepo/common // npm-lerna-monorepo/packages/common/package.json
{
  "name": "@npm-lerna-monorepo/common", // Change the package name
  "private": true,
  "version": "0.0.0",
  "type": "module",
  "main": "./src/main.tsx", // Define the entrypoint file
  ...
} We should now be able to import components from the package very easily after linking it with the package. common client Let's now create our package, for that we'll move inside the packages directory and run the following command: client # npm-lerna-monorepo/packages
npm create vite@latest client --template react-ts Our project structure after running the above command should look somewhat like this: Let's update the of the client package now to extend the base Typescript configuration that we've defined at the root level. tsconfig.json To do that add the following line of code at the beginning of : client/tsconfig.json // npm-lerna-monorepo/packages/client/tsconfig.json
{
  "extends": "../../tsconfig.json",
  ...
} Now add the package as one of the dependencies for the package, we can add the common package using the name that we've defined in its file. common client package.json // npm-lerna-monorepo/packages/client/package.json
{
  "name": "@npm-lerna-monorepo/client", // Updated the name
  ...
  "dependencies": {
    "react": "^18.2.0",
    "react-dom": "^18.2.0",
    "@npm-lerna-monorepo/common": "*" // Added common package
    ...
  }, We've also changed the name of the package according to the monorepos workspace naming convention. client Let's link both of our packages together by running from the root level. npm install # npm-lerna-monorepo
npm install This will link both packages together and now we can easily import the Button component from the package and use it in our package. common client // npm-lerna-monorepo/packages/client/src/App.tsx
import { Button } from "@npm-lerna-monorepo/common"

const App = () => {
  return <Button buttonText="Hello world" />
}

export default App; Run the dev server for package now. client # npm-lerna-monorepo/packages/client
npm run dev Open on your favorite web browser and you should see a button rendered on the UI. localhost:5173 So we have successfully setup up our monorepo using Npm workspaces and Lerna and while you are in our local environment, any changes you will make to the package will immediately reflect on the . common client Hooray 🎉 You can find the complete code of the setup . here Conclusion In this article, we have seen how we can set up and manage a monorepo with Lerna and Npm workspaces. Though Lerna is a great tool, you don't need to include it in all of your monorepos it's mainly suitable for large applications where you have multiple packages that you need to manage simultaneously. While this article was majorly focused on the setup part, if you are interested in reading more about how we can use Lerna to build and publish our monorepos please let me know in the comments. I hope this blog could a little value to you. If you liked it please share it with those who might find it helpful and show some ❤️ to the article. You can also follow me on where I post more content on Javascript, React, Software Engineering, and other stuff. Twitter Also published . here

Setting up Monorepo With Npm Workspaces and Lerna

As an entrepreneur or business owner, you're well aware of the blood, sweat, and tears that go into building something from the ground up. The endless hours of meticulous planning and execution, those back-to-back all-nighters, and the unwavering focus and drive it takes to succeed. You know what's essential for all that? A well-organized and controlled workspace. I've been riding this rollercoaster called business for quite a while now, and trust me, my work hours weren't always as productive as they are today. It's honestly a bit daunting to think about the time I lost because I couldn't concentrate. But you know what? It wasn't some earth-shattering discovery or motivational book that turned things around for me. It was a bunch of small, everyday life hacks that I gradually applied to different aspects of my life, like my sleep patterns, work habits, time management, health, and fitness - and of course, my physical surroundings. That's what I'm thrilled to share with you today. Can you imagine that clearing up your desk can make a world of difference in your productivity? Or that making a few ergonomic tweaks can give you an energy boost? Let's explore some of my go-to workspace hacks that have helped me achieve more consistent productivity. (Get ready to be surprised!) 1. Pay Attention To Your Eye Line I listened to an incredible recently by the one and only Dr. Andrew Huberman. If you've never listened to or read anything from this brilliant mind, now's the time; I highly recommend that you go check out his podcast, website, and YouTube channel. I'm a huge fan. podcast episode During the episode, Huberman mentions an interesting function of the eye. Different neurons are fired in our brains depending on the direction we move our eye line. If we look upward, for instance, we're going to experience feelings of alertness. Looking down activates the opposite – feelings of calm and sleep. You can use this understanding to biohack your workspace. Huberman suggests that looking just slightly above your usual straight-ahead eye line triggers optimal alertness. For me personally, I've leveraged this by placing my monitors just above eyeline; I'm automatically prompted to look slightly upward and be more alert as a result. 2. Choose Your Space Have you ever heard of the ? It's one of the coolest concepts I've come across in recent years. Cathedral Effect The idea is simple: if you want to be productive in creative endeavors, you should ideally be sitting under a high 'cathedral' ceiling. Acclaimed creative architect "...our perception of mental space moves in parallel with our perception of physical space." When we're under a tall ceiling, it's as though our mind gets drawn upward – our eyes, our emotions, our aspirations, and our ambitions. Creativity flows freely. Donald Rattner writes that That's why you'll notice such tall ceilings in coworking spaces, churches, and even libraries. Now I'm not suggesting you go out and buy a cathedral ceiling for your home office – but if you have the option to choose where to work, it's worth considering the psychological effects of different spaces. Low ceilings, in fact, are excellent for technical and detail-oriented work. All your senses focus in on the task at hand. Experiment with working in different parts of your home; you might just find that your new environment sparks something different in you, or works more cohesively with your specific tasks. 3. Refine Your Tech I love Apple products – I really do. They're of exceptional quality, and I rarely (if ever) encounter issues with a Mac. But when it comes to ergonomics? Laptops in general have a lot to answer for. Think about it: Laptops sit almost flush with your desk, meaning you're far more prone to leaning your wrists on the desk edge. That's a surefire way to get stuck with Carpal Tunnel Syndrome (CTS). There's no elevation – a lot of the time, you're looking downward at the screen, which strains both your neck and eye muscles. As we discussed before, looking down makes you sleepy; not ideal for productivity. The trackpad has absolutely zero ergonomic value. Your palm isn't supported at all. The keyboard has limited tactile feedback. (It's not a huge issue – just a bit sad!) If you're still struggling along with a low screen, flat keyboard, and feeble trackpad, something needs to change. And contrary to what you might have been told, it doesn't need to cost an arm and a leg. Unless you're prepared to buy a monitor with a stand, there are other ways to elevate your laptop screen. You can get a laptop stand for under $20 that perfectly lifts your laptop to eye line height. It'll keep you alert and ensure those neck muscles aren't being over-extended. An ergonomic mouse might set you back around $40 – and believe me, it's worth it. You'd be surprised at just how much effort it takes to maneuver a trackpad. Ergonomic mice support the natural curvature of your hand so you hardly need to exert at all. Finally, you'll benefit from a mechanical keyboard; it's a that mechanical keyboards both boost productivity and reduce the occurrence of CTS. (Plus, they're incredibly satisfying to type with). Pair it with a cushioned palm rest, and you're firing on all cylinders. science-backed fact 4. Become A Background Noise DJ We tend to think of our workspace as just the physical pieces – a desk, a chair, a computer, a mouse. Perhaps a second screen. But what about the environment? And more specifically, the noise you're surrounded by? For a long time, it was assumed that total silence works best in terms of productivity. Plenty of research has been conducted since then; we now understand that different frequencies are better for different tasks. For example: White, pink, and brown noise is an excellent accompaniment to shorter bursts of energy. Binaural beats are better for writing and other cognitive tasks that require focus. Ambient music is great for prolonged periods of work – it keeps your mind engaged without distracting you from the task at hand. YouTube is your go-to source for background music and ambient noise. There are plenty of creators releasing hours upon hours of content – all free. With a little trial and error, you'll soon find the perfect soundscape to accompany your work. Don't be afraid to experiment. The research is there, but still, we're all unique; our minds don't follow strict rules, and our preferences often differ. You might find pink noise repulsive or binaural beats sleep-inducing. Test the waters to find what works best for you. 5. Free Your Setup of Friction What I've found in my many hours of sitting at a desk is that – alongside the biohacking – productivity is about making your work frictionless. For instance: do you have to switch all of your cords in and out due to a lack of power points? Every time you have to swap your laptop charger out for a phone charger or lamp, you're breaking focus. What about the mess – do you let clutter build and forget to tidy up at the end of the day? The next day, you'll have to move the mess before starting work. More friction. And what about your charging etiquette? Do you make sure everything's plugged in before going to bed? If you're waiting for a laptop or keyboard to charge up in the morning, you place even more resistance between yourself and the workday ahead. It's work critically looking at your setup to see what could be altered. I've added some surge-protected powerboards to my wall, and it makes cord management much easier. I've also got a bin right next to my desk so that mess doesn't need to build up. Another thing to think about is the emotional friction getting in your way. Do you actually enjoy the space you're working in? Could you make it feel more lively with some plants or artwork? I've found that a few small touches can make my workspace feel more inviting and reduce the amount of mental resistance I have to face each day. Friction adds up quickly, and it's the enemy of productivity – but free your setup of as much resistance as possible, and you'll be surprised by how much easier work becomes. Wrap Up These tips should help you optimize your workspace for productivity. Remember: it's about more than what’s physically in front of you – background noise and emotional resistance are all factors that need to be considered too. A few small tweaks here and there can make a huge difference. You don't need to do a complete overhaul, and you certainly don't need to spend thousands on a new setup. See how small changes can compound to make a big impact, and you'll soon be working smarter – not harder. Thanks for reading, as always! If you enjoyed this article, I’d love to hear from you. at me and I'll do my best to get back to everyone! Tweet @ScottDClary Also published here .

How to Hack Your Workspace for Sustained Productivity

Monorepos are hot these days and they can significantly improve the development workflow and productivity among teams. In this article, we will talk about how to set up a monorepo with Vite, Typescript, and pnpm workspaces. What is a monorepo? Before we jump into the setup, we first need to understand what is a monorepo and why should we care about it. A monorepo is a repository that contains many distinct projects which are somewhat dependent on each other but are logically independent - meaning different teams can work on them in isolation. Let's say we’re building an application and we have two projects inside of it: : This will have all our shared components that can be used by different projects. Shared : This is going to be our main project which will be the consumer of our package. Main Shared One way to work with this type of project is a multi-repo approach where we create two separate repositories and host them at the npm registry. Then, the consumer app can install it from the npm registry and use it how we import and use , , and other packages. React Tailwind Material-UI The problem with this type of workflow is every time we will make any new changes to the package, we will have to publish the app again to the npm registry for the consumer app to get the latest changes and use them. shared Monorepos can significantly improve this workflow by packaging both of these projects into a single repository and importing components directly from the workspace instead of importing them from the cloud. Setup with pnpm workspaces Now that we have an idea about what monorepos are and what problems they solve, let's dive right into the setup and see how we can set up a basic monorepo with . pnpm workspaces To follow along you must have pnpm and node installed on your machine. Scaffold a new project The first thing that we need to do for our setup is, create a new project which we will call "pnpm-monorepo" you can of course name it whatever you want to. mkdir pnpm-monorepo Then let's go inside the root of our project and initialize a file. package.json # pnpm monorepo
pnpm init At this point, you should have a basic at the root of your project with somewhat similar code as follows: package.json // pnpm-monorepo/package.json
{
  "name": "pnpm-monorepo",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
} Now, let's install some of our root-level dependencies that we are going to use across the project. # pnpm-monorepo
pnpm add -D typescript typescript-node Once the common dependencies are installed let's create our base Typescript configuration with the following code: // pnpm-monorepo/tsconfig.base.json
{
  "compilerOptions": {
    "strict": true,
    "strictNullChecks": true,
    "esModuleInterop": true,
    "emitDecoratorMetadata": true,
    "experimentalDecorators": true,
    "noUnusedLocals": true,
    "skipLibCheck": true,
    "sourceMap": true,
    "jsx": "react-jsx",
    "moduleResolution": "node"
  }
} This is the default Typescript configuration that I have written for my project you can customize it based on your project's requirements. Next, we will create our file which will extend our tsconfig.json tsconfig.base.json // pnpm-monorepo/tsconfig.json
{
  "extends": "./tsconfig.base.json"
} That's all we need for our Typescript configuration. Now let's create a file at the root of our project that will tell what packages we will have inside our monorepo. pnpm-workspace.yaml pnpm pnpm-workspace makes it surprisingly easier to add and manage multiple packages in a project. # pnpm-monrepo/pnpm-workspace.yaml
packages:
  - "./packages/**" We can add as many packages as we want to by adding the relative path of the packages in this file, for our project we are adding our directory and all of its child directories to the workspace. pnpm-workspace.yaml packages Now we will create both of our and packages that we discussed above inside the directory. Our project will be a application and the project will have some shared code that we will use inside our main app. main shared packages main Vite shared Create a Vite application Let's first create the packages directory at the root level. # pnpm-monorepo
mkdir packages Now we will create our app inside of the packages directory which will be a application. To do that navigate inside and run: main Vite pnpm-monorepo/packages # pnpm-monorepo/packages
pnpm create vite I am using React & Typescript but the following steps should work irrespective of which framework/library you select. Now let's create our second package in the packages directory, we will call it shared. # pnpm-monorepo/packages
mkdir shared At this point, your project's structure should look somewhat similar to this: We have our packages directory and inside it, we have our and packages. main shared Let's now go inside our package and change the following in main package.json // pnpm-monorepo/packages/main/package.json
{
"name": "@pnpm-monorepo/main"
...
} For to properly identify that this package is part of our workspace, we need to change the name property of the package to . In this case, our root name is . pnpm @root-name/package-name pnpm-monorepo Now let's go inside our package and do the same but first, we need to create a file inside of it. shared package.json # pnpm-monorepo/packages/shared
pnpm init This will create a file inside our package, now let's change the following: package.json shared // pnpm-monorepo/packages/second/package.json
{
    "name": "@pnpm-monorepo/shared"
} , now we should be able to import packages from the workspace similar to how we do for other npm packages. That's it for the configuration part Let's create a file inside our package with the following code: index.ts shared // pnpm-monorepo/packages/shared/index.ts
export const sayHi = (userName: string) => console.log(`Hi ${userName}`) We have a basic function which takes a as parameter and console log a message saying "Hi" to them. sayHi userName Now, let's go inside our package and import our package by running this command: main shared # pnpm-monorepo/packages/main
pnpm add @pnpm-monorepo/shared According to docs, if we do within a workspace, it first tries to find that package within the workspace, and only if it is unable to find the package within the workspace it goes to the npm registry to install it. pnpm pnpm add As we already have within our workspace, it will install it from the workspace itself. @pnpm-monorepo/shared At this point your inside you app should look something like this: package.json main // pnpm-monorepo/packages/main/package.json
{
...
"dependencies": {
    "@pnpm-monorepo/shared": "workspace:^1.0.0",
    "react": "^18.2.0",
    "react-dom": "^18.2.0"
  },
...
} That's it, now we should be able to import variables/functions from our package. shared Let's go inside our and add the following code: main/App.tsx // pnpm-monorepo/packages/main/App.tsx
import { sayHi } from "@pnpm-monorepo/shared";

const App = () => {
  sayHi("Vedansh");
  return <h1>Main app</h1>;
};
export default App; Run and inside app, a new dev server should spin up and you should see the following output at your : pnpm install pnpm dev main http://localhost:5173 So that's it, this was our very basic monorepo setup with pnpm-workspaces, Vite, and Typescript. Monorepos is a great solution for large-scale applications where you don't want to manage multiple repositories for multiple packages and instead you want to package all of them together into one repository. If you want the complete code of this project you can find it . here Thank you for reading, if you are still here consider following me for more blogs. Also published . here

How to Set Up a Monorepo With Vite, TypeScript, and Pnpm Workspaces

Recent studies have found that can actually decrease productivity.  In a digital environment, employees use an average of nine apps to complete their tasks. Executives are constantly checking emails, notifications, and direct messages to stay updated on their workload. This constant switching of applications accounts for a 40% loss in productivity, with each interruption to a task requiring 23 minutes to completely regain focus. remote work Aside from balancing a digital work environment, remote meetings have been found to waste time, as 83% of employees report spending up to one-third of their work weeks in video conferences.  This digital interaction is even more stressful on employees, with intimate face-to-face interactions adding to workplace anxiety and fatigue.  Nearly half of all virtual employees say that being on camera makes them more exhausted, and the closeness of the camera to both oneself and other employees adds levels of stress as well. To combat this potentially negative work environment, companies are developing online workspaces to better reflect the convenience and personality of an office environment. It is noticeable that 78% of employees wish to continue working remotely for the rest of their career; but also notice that 49% miss seeing colleagues, and one-quarter miss in-person meetings.  As such, the online office space designed for Web3 communities, online event providers, and startups has been created to combine the best of both worlds. For example, every digital building in has a real-world street address owned in the form of an NFT.  Each building has floors with different layouts and user permissions, and each individual room is even more customizable. Rooms can be shared or individual, and a sense of privacy is important with employees knocking on closed doors before being allowed to enter. RedRex Rooms have voice, video, and text chats to allow seamless communication regardless of what each person is comfortable with.  Media such as pictures and videos can be shared within rooms to discuss and change on the spot.  The security features double down with each floor having its own security access badge.  Overall, digital workspaces create a single space to create and communicate that connects employees both online and in-person.

Digital Workspaces: Hacking the Future of Work

Hello everyone! Postman is one of the most popular API testing tools - it combines the ability to test things manually and add some sort of automation to it. In this article you’ll know how to best organize your Workspace in Postman - it’ll help you faster reach any request your need and get rid of some manual tasks like renewing your authorization token. So let’s begin with the creation of a new Workspace! Environment Usually, there are at least a few environments in most of the projects - (where developers upload their features first and might test them on their end), (platform for QA verification) and , of couse. development staging production Every environment has a bit different base url, but path (route) usually stays the same. For example: - production https://example.com/some/route - https:// .example.com/some/route staging staging - https:// .example.com/some/route development dev See? In case of and environments - they simple have subdomains assigned, but the path (some/route) stays the same. It means that base url is one of our first candidates to become an - a value that changes between environments. staging development environment variable Usage of base url as an environment variable let us use a single template in Postman to send a request to any environment that we have configured in our collection. Now let’s create a new Environment and name it . These are the variables that we’re going to add: Production baseUrl value - https://paysis.herokuapp.com base url of test application that we’ll use in current article token authorization token - it’ll be updated dynamically, so it must be empty for now login value - adminius login for auth request password value - supers3cret password for auth request And don’t forget to click button to save our current progress with the environment. Save Production Collection Now it’s time to create a Collection to organize our templates - it is as simple as our previous step with environment variables. Let’s name new collection and select as an since this is the one that current application use. Below, in section, enter environment variable (don’t forget to put parentheses as well - that’s how you address to environment variables in Postman). After that select the Environment that we created in our previous step. Paysis Bearer Token Authorization Type Token baseUrl Once again, don’t forget to Save current collection - either press ( ) / ( ) or click (three dots) button. Control + S Windows / Linux Command + S MacOS View more actions Our Authorization config will be applied for every request in the current Collection automatically. Authorization Let’s create our first request - this one is going to be an authorization request which makes our further testing possible (since we need an authorization token to send other requests as an authorized user). To create a new request template - simply click right mouse button on your Collection name in list and select . Let’s name this one . Add Request Auth It is a request to endpoint with body: POST /auth JSON {
  "login": "{{login}}",
  "password": "{{password}}"
} , and are environment variables there that are taken from environment that we’ve created earlier. baseUrl login password Production There’s one thing that we’d want to automate here - update environment variable with a value from this request’s response, so we can reuse this value in other requests that must be executed under authorized user. To do that, let’s go to tab in current request and paste this code there: token Tests var responseData = JSON.parse(responseBody);
postman.setEnvironmentVariable("token", responseData.token); This section is there for small automated tests and scripts (just like the one that we already implemented). It accepts only. Once you’ll send a request - code from this section will be executed. JavaScript By the way, since this request doesn’t require any authentication header - we must remove it (because it was automatically applied by collection). To do that - simply go to tab of current request and select No Auth in the dropdown. Authorization Now it’s safe to execute our first request in the collection - hit button. Send Once you’ve done that - you’ll see authorization token from response in your current environment. This variable with your token will be included by default in your future requests of the current collection. Auth Functional Separation of Requests After some time you’ll see that your collection is growing and it’s hard to find a request that you need in this mess. It’s better to separate requests by groups (sub-collections of collections) right from the start. For , we have request in the root of the collection. For other logic ( , , ) there are sub-collections. Paysis Auth Users Transactions Config Don’t forget about proper naming of requests so other people could find whatever they need as well. Summary So here’s what you need for the best experience with : Postman Use in your workspace to adapt your requests to various environment. environment variables Add that automate data transitions between requests (like sharing authorization token from request into all other requests). scripts Auth Create and . sub-collections name your requests properly Thanks for reading, I hope you’ve learned something new!

WORKSPAN

workspan.com

-- employees

Since n.d.

COMPANY RANKING

WORKSPAN

EVERGREEN INDEX #11756

Representing this company? Click here to claim and customize this page!

WorkSpan WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

WORKSPAN

workspan.com

-- employees

Since n.d.

COMPANY RANKING

WORKSPAN

EVERGREEN INDEX #11756

RELATED COMPANIESRANK

STORIES ABOUT WORKSPAN

Representing this company? Click here to claim and customize this page!

WorkSpan WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!