Panoslice is a seamless carousel maker, useful for microcontent on sites like Linkedin, Instagram, Facebook, Twitter etc

Panoslice

panoslice

Building an Invoice PDF system with , , and can be a complex task, but I'm here to guide you through the process. React.js Redux Node.js Here's a step-by-step tutorial on how you can create such a system: You can find the Github Repository for this project here: https://github.com/idurar/idurar-erp-crm Content Overview Step 1: Setting up the environment Step 2: Setting up the server (Node.js/Express) Step 3: Building the React.js application Step 4: Integrating React.js with Node.js Step 5: Styling and enhancing the user interface Step 6: Testing and debugging Step 7: Deployment Step 1: Setting up the environment Make sure you have Node.js installed on your machine. Create a new directory for your project and navigate into it using the terminal. Initialize a new Node.js project by running . npm init Install required dependencies by running . npm install react redux react-redux Step 2: Setting up the server (Node.js/Express) Create a new file called and set up a basic Express server. server.js Import the necessary dependencies ( , ) in the server file. express html-pdf Define routes for generating and downloading invoices. const express = require('express');

const helmet = require('helmet');
const path = require('path');
const cors = require('cors');

const cookieParser = require('cookie-parser');
require('dotenv').config({ path: '.variables.env' });

const helpers = require('./helpers');

const erpApiRouter = require('./routes/erpRoutes/erpApi');
const erpAuthRouter = require('./routes/erpRoutes/erpAuth');
const erpDownloadRouter = require('./routes/erpRoutes/erpDownloadRouter');

const errorHandlers = require('./handlers/errorHandlers');

const { isValidAdminToken } = require('./controllers/erpControllers/authJwtController');

// create our Express app
const app = express();
// serves up static files from the public folder. Anything in public/ will just be served up as the file it is

// Takes the raw requests and turns them into usable properties on req.body

app.use(helmet());
app.use(cookieParser());
app.use(express.json());
app.use(express.urlencoded({ extended: true }));
app.use(express.static(path.join(__dirname, 'public')));



// pass variables to our templates + all requests

app.use((req, res, next) => {
  res.locals.h = helpers;
  res.locals.admin = req.admin || null;
  res.locals.currentPath = req.path;
  const clientIP = req.socket.remoteAddress;
  let isLocalhost = false;
  if (clientIP === '127.0.0.1' || clientIP === '::1') {
    // Connection is from localhost
    isLocalhost = true;
  }
  res.locals.isLocalhost = isLocalhost;
  next();
});

// app.use(function (req, res, next) {
//   if (req.url.slice(-1) === "/" && req.path.length > 1) {
//     // req.path = req.path.slice(0, -1);
//     req.url = req.url.slice(0, -1);
//   }
//   next();
// });

// Here our API Routes

var corsOptionsDelegate = function (req, callback) {
  var corsOptions;
  const clientIP = req.socket.remoteAddress;
  let isLocalhost = false;
  if (clientIP === '127.0.0.1' || clientIP === '::1') {
    // Connection is from localhost
    isLocalhost = true;
  }
  if (isLocalhost) {
    corsOptions = {
      origin: '*',
      credentials: true,
    };
  } else {
    corsOptions = {
      origin: true,
      credentials: true,
    };
  }
  callback(null, corsOptions); // callback expects two parameters: error and options
};

app.use(
  '/api',
  cors({
    origin: true,
    credentials: true,
  }),
  erpAuthRouter
);

app.use(
  '/api',
  cors({
    origin: true,
    credentials: true,
  }),
  isValidAdminToken,
  erpApiRouter
);

app.use('/download', cors(), erpDownloadRouter);

// If that above routes didnt work, we 404 them and forward to error handler
app.use(errorHandlers.notFound);

// Otherwise this was a really bad error we didn't expect! Shoot eh
if (app.get('env') === 'development') {
  /* Development Error Handler - Prints stack trace */
  app.use(errorHandlers.developmentErrors);
}

// production error handler
app.use(errorHandlers.productionErrors);

// done! we export it so we can start the site in start.js
module.exports = app; Step 3: Building the React.js application In the root directory of your project, create a new folder called . client Navigate into the folder and run to generate a new React.js application. client npx create-react-app . Replace the contents of the generated folder with your own code. src Create components for the invoice form, invoice list, and invoice detail view. Use Redux to manage the state of your application, including the invoice data. import React from 'react';
import dayjs from 'dayjs';
import { Tag } from 'antd';
import InvoiceModule from '@/modules/InvoiceModule';
import { useMoney } from '@/settings';

export default function Invoice() {
  const { moneyRowFormatter } = useMoney();

  const entity = 'invoice';
  const searchConfig = {
    displayLabels: ['name', 'surname'],
    searchFields: 'name,surname,birthday',
  };
  const entityDisplayLabels = ['number', 'client.company'];
  const dataTableColumns = [
    {
      title: '#N',
      dataIndex: 'number',
    },
    {
      title: 'Client',
      dataIndex: ['client', 'company'],
    },
    {
      title: 'Date',
      dataIndex: 'date',
      render: (date) => {
        return dayjs(date).format('DD/MM/YYYY');
      },
    },
    {
      title: 'Due date',
      dataIndex: 'expiredDate',
      render: (date) => {
        return dayjs(date).format('DD/MM/YYYY');
      },
    },
    {
      title: 'Total',
      dataIndex: 'total',
      render: (amount) => moneyRowFormatter({ amount }),
    },
    {
      title: 'Balance',
      dataIndex: 'credit',
      render: (amount) => moneyRowFormatter({ amount }),
    },
    {
      title: 'status',
      dataIndex: 'status',
      render: (status) => {
        let color = status === 'draft' ? 'cyan' : status === 'sent' ? 'magenta' : 'gold';

        return <Tag color={color}>{status && status.toUpperCase()}</Tag>;
      },
    },
    {
      title: 'Payment',
      dataIndex: 'paymentStatus',
      render: (paymentStatus) => {
        let color =
          paymentStatus === 'unpaid'
            ? 'volcano'
            : paymentStatus === 'paid'
            ? 'green'
            : paymentStatus === 'overdue'
            ? 'red'
            : 'purple';

        return <Tag color={color}>{paymentStatus && paymentStatus.toUpperCase()}</Tag>;
      },
    },
  ];

  const PANEL_TITLE = 'invoice';
  const dataTableTitle = 'invoices Lists';
  const ADD_NEW_ENTITY = 'Add new invoice';
  const DATATABLE_TITLE = 'invoices List';
  const ENTITY_NAME = 'invoice';
  const CREATE_ENTITY = 'Save invoice';
  const UPDATE_ENTITY = 'Update invoice';

  const config = {
    entity,
    PANEL_TITLE,
    dataTableTitle,
    ENTITY_NAME,
    CREATE_ENTITY,
    ADD_NEW_ENTITY,
    UPDATE_ENTITY,
    DATATABLE_TITLE,
    dataTableColumns,
    searchConfig,
    entityDisplayLabels,
  };
  return <InvoiceModule config={config} />;
} Step 4: Integrating React.js with Node.js In your React.js application, make HTTP requests to the server endpoints created in Step 2 using libraries like or . axios fetch When submitting the invoice form, send the form data to the server and handle the creation of the PDF invoice on the server side. Retrieve the generated PDF from the server and display a link or button to let users download it. import React, { useState, useEffect } from 'react';
import { Form, Divider } from 'antd';

import { Button, PageHeader, Row, Statistic, Tag } from 'antd';

import { useSelector, useDispatch } from 'react-redux';
import { erp } from '@/redux/erp/actions';
import { selectCreatedItem } from '@/redux/erp/selectors';

import { useErpContext } from '@/context/erp';
import uniqueId from '@/utils/uinqueId';

import Loading from '@/components/Loading';
import { CloseCircleOutlined, PlusOutlined } from '@ant-design/icons';

function SaveForm({ form, config }) {
  let { CREATE_ENTITY } = config;
  const handelClick = () => {
    form.submit();
  };

  return (
    <Button onClick={handelClick} type="primary" icon={<PlusOutlined />}>
      {CREATE_ENTITY}
    </Button>
  );
}

export default function CreateItem({ config, CreateForm }) {
  let { entity, CREATE_ENTITY } = config;
  const { erpContextAction } = useErpContext();
  const { createPanel } = erpContextAction;
  const dispatch = useDispatch();
  const { isLoading, isSuccess } = useSelector(selectCreatedItem);
  const [form] = Form.useForm();
  const [subTotal, setSubTotal] = useState(0);
  const handelValuesChange = (changedValues, values) => {
    const items = values['items'];
    let subTotal = 0;

    if (items) {
      items.map((item) => {
        if (item) {
          if (item.quantity && item.price) {
            let total = item['quantity'] * item['price'];
            //sub total
            subTotal += total;
          }
        }
      });
      setSubTotal(subTotal);
    }
  };

  useEffect(() => {
    if (isSuccess) {
      form.resetFields();
      dispatch(erp.resetAction({ actionType: 'create' }));
      setSubTotal(0);
      createPanel.close();
      dispatch(erp.list({ entity }));
    }
  }, [isSuccess]);

  const onSubmit = (fieldsValue) => {
    if (fieldsValue) {
      // if (fieldsValue.expiredDate) {
      //   const newDate = fieldsValue["expiredDate"].format("DD/MM/YYYY");
      //   fieldsValue = {
      //     ...fieldsValue,
      //     expiredDate: newDate,
      //   };
      // }
      // if (fieldsValue.date) {
      //   const newDate = fieldsValue["date"].format("DD/MM/YYYY");
      //   fieldsValue = {
      //     ...fieldsValue,
      //     date: newDate,
      //   };
      // }
      if (fieldsValue.items) {
        let newList = [...fieldsValue.items];
        newList.map((item) => {
          item.total = item.quantity * item.price;
        });
        fieldsValue = {
          ...fieldsValue,
          items: newList,
        };
      }
    }
    dispatch(erp.create({ entity, jsonData: fieldsValue }));
  };

  return (
    <>
      <PageHeader
        onBack={() => createPanel.close()}
        title={CREATE_ENTITY}
        ghost={false}
        tags={<Tag color="volcano">Draft</Tag>}
        // subTitle="This is create page"
        extra={[
          <Button
            key={`${uniqueId()}`}
            onClick={() => createPanel.close()}
            icon={<CloseCircleOutlined />}
          >
            Cancel
          </Button>,
          <SaveForm form={form} config={config} key={`${uniqueId()}`} />,
        ]}
        style={{
          padding: '20px 0px',
        }}
      ></PageHeader>
      <Divider dashed />
      <Loading isLoading={isLoading}>
        <Form form={form} layout="vertical" onFinish={onSubmit} onValuesChange={handelValuesChange}>
          <CreateForm subTotal={subTotal} />
        </Form>
      </Loading>
    </>
  );
} Step 5: Styling and enhancing the user interface Utilize CSS and any CSS framework of your choice (e.g., Ant Design) to style your application. Enhance the user interface with features like pagination, sorting, searching, and filtering invoices. import React, { useState, useEffect, useRef } from 'react';
import dayjs from 'dayjs';
import { Form, Input, InputNumber, Button, Select, Divider, Row, Col } from 'antd';

import { PlusOutlined } from '@ant-design/icons';

import { DatePicker } from '@/components/CustomAntd';

import AutoCompleteAsync from '@/components/AutoCompleteAsync';
import ItemRow from '@/components/ErpPanel/ItemRow';

import MoneyInputFormItem from '@/components/MoneyInputFormItem';

export default function InvoiceForm({ subTotal = 0, current = null }) {
  const [total, setTotal] = useState(0);
  const [taxRate, setTaxRate] = useState(0);
  const [taxTotal, setTaxTotal] = useState(0);
  const [currentYear, setCurrentYear] = useState(() => new Date().getFullYear());
  const handelTaxChange = (value) => {
    setTaxRate(value);
  };

  useEffect(() => {
    if (current) {
      const { taxRate = 0, year } = current;
      setTaxRate(taxRate);
      setCurrentYear(year);
    }
  }, [current]);
  useEffect(() => {
    const currentTotal = subTotal * taxRate + subTotal;
    setTaxTotal((subTotal * taxRate).toFixed(2));
    setTotal(currentTotal.toFixed(2));
  }, [subTotal, taxRate]);

  const addField = useRef(false);

  useEffect(() => {
    addField.current.click();
  }, []);

  return (
    <>
      <Row gutter={[12, 0]}>
        <Col className="gutter-row" span={9}>
          <Form.Item
            name="client"
            label="Client"
            rules={[
              {
                required: true,
                message: 'Please input your client!',
              },
            ]}
          >
            <AutoCompleteAsync
              entity={'client'}
              displayLabels={['company']}
              searchFields={'company,managerSurname,managerName'}
              // onUpdateValue={autoCompleteUpdate}
            />
          </Form.Item>
        </Col>
        <Col className="gutter-row" span={5}>
          <Form.Item
            label="Number"
            name="number"
            initialValue={1}
            rules={[
              {
                required: true,
                message: 'Please input invoice number!',
              },
            ]}
          >
            <InputNumber style={{ width: '100%' }} />
          </Form.Item>
        </Col>
        <Col className="gutter-row" span={5}>
          <Form.Item
            label="year"
            name="year"
            initialValue={currentYear}
            rules={[
              {
                required: true,
                message: 'Please input invoice year!',
              },
            ]}
          >
            <InputNumber style={{ width: '100%' }} />
          </Form.Item>
        </Col>
        <Col className="gutter-row" span={5}>
          <Form.Item
            label="status"
            name="status"
            rules={[
              {
                required: false,
                message: 'Please input invoice status!',
              },
            ]}
            initialValue={'draft'}
          >
            <Select
              options={[
                { value: 'draft', label: 'Draft' },
                { value: 'pending', label: 'Pending' },
                { value: 'sent', label: 'Sent' },
              ]}
            ></Select>
          </Form.Item>
        </Col>
        <Col className="gutter-row" span={9}>
          <Form.Item label="Note" name="note">
            <Input />
          </Form.Item>
        </Col>
        <Col className="gutter-row" span={8}>
          <Form.Item
            name="date"
            label="Date"
            rules={[
              {
                required: true,
                type: 'object',
              },
            ]}
            initialValue={dayjs()}
          >
            <DatePicker style={{ width: '100%' }} format={'DD/MM/YYYY'} />
          </Form.Item>
        </Col>
        <Col className="gutter-row" span={7}>
          <Form.Item
            name="expiredDate"
            label="Expire Date"
            rules={[
              {
                required: true,
                type: 'object',
              },
            ]}
            initialValue={dayjs().add(30, 'days')}
          >
            <DatePicker style={{ width: '100%' }} format={'DD/MM/YYYY'} />
          </Form.Item>
        </Col>
      </Row>
      <Divider dashed />
      <Row gutter={[12, 12]} style={{ position: 'relative' }}>
        <Col className="gutter-row" span={5}>
          <p>Item</p>
        </Col>
        <Col className="gutter-row" span={7}>
          <p>Description</p>
        </Col>
        <Col className="gutter-row" span={3}>
          <p>Quantity</p>
        </Col>
        <Col className="gutter-row" span={4}>
          <p>Price</p>
        </Col>
        <Col className="gutter-row" span={5}>
          <p>Total</p>
        </Col>
      </Row>
      <Form.List name="items">
        {(fields, { add, remove }) => (
          <>
            {fields.map((field) => (
              <ItemRow key={field.key} remove={remove} field={field} current={current}></ItemRow>
            ))}
            <Form.Item>
              <Button
                type="dashed"
                onClick={() => add()}
                block
                icon={<PlusOutlined />}
                ref={addField}
              >
                Add field
              </Button>
            </Form.Item>
          </>
        )}
      </Form.List>
      <Divider dashed />
      <div style={{ position: 'relative', width: ' 100%', float: 'right' }}>
        <Row gutter={[12, -5]}>
          <Col className="gutter-row" span={5}>
            <Form.Item>
              <Button type="primary" htmlType="submit" icon={<PlusOutlined />} block>
                Save Invoice
              </Button>
            </Form.Item>
          </Col>
          <Col className="gutter-row" span={4} offset={10}>
            <p
              style={{
                paddingLeft: '12px',
                paddingTop: '5px',
              }}
            >
              Sub Total :
            </p>
          </Col>
          <Col className="gutter-row" span={5}>
            <MoneyInputFormItem readOnly value={subTotal} />
          </Col>
        </Row>
        <Row gutter={[12, -5]}>
          <Col className="gutter-row" span={4} offset={15}>
            <Form.Item
              name="taxRate"
              rules={[
                {
                  required: false,
                  message: 'Please input your taxRate!',
                },
              ]}
              initialValue="0"
            >
              <Select
                value={taxRate}
                onChange={handelTaxChange}
                bordered={false}
                options={[
                  { value: 0, label: 'Tax 0 %' },
                  { value: 0.19, label: 'Tax 19 %' },
                ]}
              ></Select>
            </Form.Item>
          </Col>
          <Col className="gutter-row" span={5}>
            <MoneyInputFormItem readOnly value={taxTotal} />
          </Col>
        </Row>
        <Row gutter={[12, -5]}>
          <Col className="gutter-row" span={4} offset={15}>
            <p
              style={{
                paddingLeft: '12px',
                paddingTop: '5px',
              }}
            >
              Total :
            </p>
          </Col>
          <Col className="gutter-row" span={5}>
            <MoneyInputFormItem readOnly value={total} />
          </Col>
        </Row>
      </div>
    </>
  );
} Step 6: Testing and debugging Use tools like React DevTools and Redux DevTools to debug your application. Write unit tests using libraries like Jest or Enzyme to ensure the stability of your codebase. Step 7: Deployment Deploy your Node.js server and React.js application to a hosting platform like Heroku, AWS, or Netlify. Configure the necessary environment variables and ensure that everything is working as expected in a production environment. You can find the Github Repository here: https://github.com/idurar/idurar-erp-crm This tutorial provides a high-level overview of building an Invoice PDF system using React.js, Redux, and Node.js. Good luck with your project! Also published . here

How to Build an Invoice PDF System Using React.js, Redux and Node.js

Five Weeks in a Balloon by Jules Verne, is part of the HackerNoon Books Series. You can jump to any chapter in this book . Chapter II here CHAPTER SECOND. The Article in the Daily Telegraph.—War between the Scientific Journals.—Mr. Petermann backs his Friend Dr. Ferguson.—Reply of the Savant Koner.—Bets made.—Sundry Propositions offered to the Doctor. On the next day, in its number of January 15th, the published an article couched in the following terms: Daily Telegraph “Africa is, at length, about to surrender the secret of her vast solitudes; a modern Œdipus is to give us the key to that enigma which the learned men of sixty centuries have not been able to decipher. In other days, to seek the sources of the Nile— —was regarded as a mad endeavor, a chimera that could not be realized. fontes Nili quærere “Dr. Barth, in following out to Soudan the track traced by Denham and Clapperton; Dr. Livingstone, in multiplying his fearless explorations from the Cape of Good Hope to the basin of the Zambesi; Captains Burton and Speke, in the discovery of the great interior lakes, have opened three highways to modern civilization. , which no traveller has yet been able to reach, is the very heart of Africa, and it is thither that all efforts should now be directed. Their point of intersection “The labors of these hardy pioneers of science are now about to be knit together by the daring project of Dr. Samuel Ferguson, whose fine explorations our readers have frequently had the opportunity of appreciating. “This intrepid discoverer proposes to traverse all Africa from east to west . If we are well informed, the point of departure for this surprising journey is to be the island of Zanzibar, upon the eastern coast. As for the point of arrival, it is reserved for Providence alone to designate. in a balloon “The proposal for this scientific undertaking was officially made, yesterday, at the rooms of the Royal Geographical Society, and the sum of twenty-five hundred pounds was voted to defray the expenses of the enterprise. “We shall keep our readers informed as to the progress of this enterprise, which has no precedent in the annals of exploration.” As may be supposed, the foregoing article had an enormous echo among scientific people. At first, it stirred up a storm of incredulity; Dr. Ferguson passed for a purely chimerical personage of the Barnum stamp, who, after having gone through the United States, proposed to “do” the British Isles. A humorous reply appeared in the February number of the of Geneva, which very wittily showed up the Royal Society of London and their phenomenal sturgeon. Bulletins de la Société Géographique But Herr Petermann, in his , published at Gotha, reduced the Geneva journal to the most absolute silence. Herr Petermann knew Dr. Ferguson personally, and guaranteed the intrepidity of his dauntless friend. Mittheilungen Besides, all manner of doubt was quickly put out of the question: preparations for the trip were set on foot at London; the factories of Lyons received a heavy order for the silk required for the body of the balloon; and, finally, the British Government placed the transport-ship , Captain Bennett, at the disposal of the expedition. Resolute At once, upon word of all this, a thousand encouragements were offered, and felicitations came pouring in from all quarters. The details of the undertaking were published in full in the bulletins of the Geographical Society of Paris; a remarkable article appeared in the (“New Annals of Travels, Geography, History, and Archaeology, by M. V. A. Malte-Brun”); and a searching essay in the , by Dr. W. Koner, triumphantly demonstrated the feasibility of the journey, its chances of success, the nature of the obstacles existing, the immense advantages of the aërial mode of locomotion, and found fault with nothing but the selected point of departure, which it contended should be Massowah, a small port in Abyssinia, whence James Bruce, in 1768, started upon his explorations in search of the sources of the Nile. Apart from that, it mentioned, in terms of unreserved admiration, the energetic character of Dr. Ferguson, and the heart, thrice panoplied in bronze, that could conceive and undertake such an enterprise. Nouvelles Annales des Voyages, de la Géographie, de l’Histoire, et de l’Archaeologie de M. V. A. Malte-Brun Zeitschrift für Allgemeine Erdkunde The could not, without some displeasure, contemplate so much glory monopolized by England. It therefore rather ridiculed the doctor’s scheme, and urged him, by all means, to push his explorations as far as America, while he was about it. North American Review In a word, without going over all the journals in the world, there was not a scientific publication, from the to the , from the to the , that had not something to say about the affair in all its phases. Journal of Evangelical Missions Revue Algérienne et Coloniale Annales de la Propagation de la Foi Church Missionary Intelligencer Many large bets were made at London and throughout England generally, first, as to the real or supposititious existence of Dr. Ferguson; secondly, as to the trip itself, which, some contended, would not be undertaken at all, and which was really contemplated, according to others; thirdly, upon the success or failure of the enterprise; and fourthly, upon the probabilities of Dr. Ferguson’s return. The betting-books were covered with entries of immense sums, as though the Epsom races were at stake. Thus, believers and unbelievers, the learned and the ignorant, alike had their eyes fixed on the doctor, and he became the lion of the day, without knowing that he carried such a mane. On his part, he willingly gave the most accurate information touching his project. He was very easily approached, being naturally the most affable man in the world. More than one bold adventurer presented himself, offering to share the dangers as well as the glory of the undertaking; but he refused them all, without giving his reasons for rejecting them. Numerous inventors of mechanism applicable to the guidance of balloons came to propose their systems, but he would accept none; and, when he was asked whether he had discovered something of his own for that purpose, he constantly refused to give any explanation, and merely busied himself more actively than ever with the preparations for his journey. 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. Jules Verne (2002). Five Weeks in a Balloon. Urbana, Illinois: Project Gutenberg. Retrieved October 2022 https://www.gutenberg.org/cache/epub/3526/pg3526-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

The Article in the Daily Telegraph

MATHEMATICAL MEMORIES: NEWTON'S BINOMIAL THEOREM

The Magic Shop

These days my preferred programming environment is a descendent called . The system allows me to quickly explore ideas, change code and I am always surprised how little code I need to get things done. I use the word environment as the programming language is just one part of it. It is the combination of compiler, editor, debugger, inspector that determine how quickly one can solve problems and I sometimes I am painfully reminded of how much ahead Pharo is, especially when writing code that resolves around . Smalltalk-80 Pharo edit, compile, run, wait , crash, add printf, repeat, wait , crash at same place but with more info, cycles But I am getting ahead of myself. I started my programming career in junior high by typing my first lines of imperative code into a terminal connected to a Unix system of my school. We used a language called and solved problems like finding primes, building guessing games, etc.. Other imperative languages followed and for a brief period I wrote things in Java but then started to mostly and write C++ and a bit of C. In University I was exposed to a fair amount of Haskell and since then I wrote scripts in Python and for the last couple of years I learn Smalltalk. ELAN read Smalltalk-80 was literally ahead of its time. It started as a bet that the semantics of a language could be described on a single piece of paper and it ran on computers that utilized . That means the very expensive computers built at Xerox Parc represented what would, thanks to Moore’s Law, become affordable in just a couple of years. The issue is that people wanting to use Smalltalk-80 couldn’t wait until the 90s and it was trapped in the ivory tower as a language for the elites with expensive computers and deep pockets. Moore’s Law From time to time I try to leave my personal ivory tower and explore other programming languages. I look at Erlang, Rust, Go and for the last couple of weeks I am debugging, fixing and writing Go code to learn the ups and downs of the language. Today I want to write about being able to reason about runtime failures and what a language/runtime can provide to make one more productive. I was parsing a network protocol where inside the message it tells me where to find the next header. In Go the message could be represented by a (an array of unsigned int taking 8-bit each, in Go read types from left to right) and I wrote something basic like that: []uint8 func NextHeader(message []uint8) []uint8 {offset := message[2]len := message[2 + offset]return message[2 + offset + 1 : len]} The experienced Python and Go programmer will spot the issue immediately but when running the resulting application it sometimes would work but for some messages it would abort with: panic: runtime error: slice bounds out of range goroutine 1 [running]: main.NextHeader(...) slicetest.go:8 The panic lacks information about which slice and what bounds. As this only happened on some of the messages I was parsing I resorted to debugging it like: func printSliceBounds(message []uint8, begin, end uint8) {if recover() != nil {fmt.Printf("%#v[%v:%v]\n", message, begin, end)}} func NextHeader(message []uint8) []uint8 {offset := message[2]len := message[2 + offset]defer printSliceBounds(message, offset, len)return message[2 + offset + 1 : len]} This will make sure that and before returning to the caller the function will be called. In case the code is recovering from a panic the formatted slice and bounds will be printed. I wanted to build a testcase with this slice but as soon as I tried to compile the code the static analysis of the Go compiler pointed out the error. after NextHeader printSliceBounds Until here this might be all pretty standard for you but I had the pleasure to work in the ivory tower. So let me tell you about of where I come from. In my world everything is an object. This includes the stackframe/activation record of the running execution and is referred to by the reserved keyword . It is an object like any other object in the system and it can be queried and . I can query the Program Counter, I can read objects from the stack, I can walk the call hierarchy, I can access the Abstract Syntax Tree of the method (a method is just another object) currently executing but I can also modify the Program Counter, context chain, etc. thisContext manipulated Smalltalk a slice error would be signaled as an Exception. In contrast to many other languages the exception handling code is not part of the Virtual Machine but a part of the runtime package and built on top of . When developing I would get a debugger in my environment that let’s me inspect the slice but when running in production I might consider to serialize the exception and the entire running process to a file. There is a nice of running Pharo on Lambda AWS and taking a “crash” and debugging it locally. thisContext demo As a thought experiment you can ask yourself how you would implement a debugger in C that runs a halted method until its end and how an implementation in Smalltalk would like? . The easiest way to do it in Smalltalk is to create a new context, put a trap/halt/breakpoint/continuation into it and place it in between the current method and the original caller and then resume the execution of the process. one can see a real implementation using this for . The beauty of a system is that with the right set of abstractions one can build things that are normally very time consuming to build Here GNU Smalltalk Exception handling has its problems and it is fair for Go to have picked a more explicit path for error propagation and panics. I started to check what it would take to add a high level out of bounds object that carries the slice and the bounds and explored the Go sourcecode. The nice thing is that the entire system builds quite quickly (e.g. compared to gcc/libstdc++). So here are my findings after working on it. The first one is the place where the compiler is generating the bounds checking: In src/cmd/compile/internal/gc/ssa.go// slice computes the slice v[i:j:k] and returns ptr, len, and cap of result.// i,j,k may be nil, in which case they are set to their default value.// t is a slice, ptr to array, or string type. func (s *state) slice(t *types.Type, v, i, j, k *ssa.Value) (p, l, c *ssa.Value) { ... s.sliceBoundsCheck(i, j)if j != k {s.sliceBoundsCheck(j, k)}if k != cap {s.sliceBoundsCheck(k, cap)}... The compiler will generate up to three checks for your invocation of the slice code. , , are user supplied and can be null and then the default values , and . The first check will always be generated and is to check that , the second if generated will check 0 ≤ j ≤ k (length ≤ capacity) and the last will check capacity ≤ existing capacity. i j k zero (i) len (j) cap (k) will be used 0 ≤ i ≤ j The ssa of a simple check might look like this: func Slice(slice []uint8, start, end int) []uint8 {return slice[start:end] // to defeat the static analysis} Slice <nil> b1:v1 = InitMem <mem>v9 = Arg <int> {start} : start[int]v10 = Arg <int> {end} : end[int]v28 = Arg <int> {slice} [16] : slice+16[int]v32 = Arg <*byte> {slice} : slice[*byte]--- Load registers and check 0 <= i <= j here.v7 = LoadReg <int> v9 : AXv15 = LoadReg <int> v10 : CXv31 = CMPQ <flags> v7 v15ULE v31 -> b2 b3 (likely)b2: <- b1--- Load k into register and check 0 <= j <= k here.v34 = LoadReg <int> v28 : DXv8 = CMPQ <flags> v15 v34ULE v8 -> b4 b3 (likely)b4: <- b2... create the new slice here and return it --- Error case jumped to from b1 (0 <= i <= j) or b2 (0 <= j <= k)b3: <- b1 b2v18 = CALLstatic <mem> {runtime.panicslice} v1Exit v18 At the time is called the information about the slice and which of the three checks failed is gone. After some exploring I can pass the error kind to , the slice and bounds as well. The first issue was to replace the manual Common Subexpression Elimination (CSE) that assumed that each line of code can only have one kind of panic but then I faced a fundamental issue. The is at the bottom of the food chain and I can’t just use to format a new error in there. First of all the system might be out of memory and second might use broken slice code itself and then the panic code would recurse into more panics. panicslice panicslice src/runtime/panic.go fmt.Errorf fmt.Errorf At that point I explored if I could use defer on the outside as a generic error handler. The idea is to install something in the that will print the faulting slice and the bounds in the error code. It would use and somehow check if it went through and then somehow find the variables and then maybe even create the boilerplate for a testcase. main() recover() panicslice While Go has built-in reflection and Program Counter to function code it doesn’t have seem to have the same for data (the stack pointer). To compare this to Smalltalk , Go gives us static information (function name, line number) but lacks dynamic information (variables in the stack). In theory it could be added (IIRC the debug format DWARFv2 has support for tracking the locations of variables) but it doesn’t seem to be used in thisContext runtime/symtab.go. I ended up making a proof of concept and patching the compiler like this: // Panic if slice indices are not in bounds. s.sliceBoundsCheck(i, j, v, i, j, s.constInt(types.Types[TINT], 1))if j != k {s.sliceBoundsCheck(j, k, v, j, k, s.constInt(types.Types[TINT], 2))}if k != cap {s.sliceBoundsCheck(k, cap, v, k, cap, s.constInt(types.Types[TINT], 3))} And the runtime code like that. Make the SliceError an errorString but provide high level information about the error: type SliceError struct {errorStringSlice interface{}Start intEnd intErrorKind int} func panicslice(slice interface{}, len int, start int, end int, kind int) {panicCheckMalloc(sliceError)panic(SliceError{errorString: sliceError.(errorString),Slice: slice,Start: start,End: end,ErrorKind: kind})} Using a defer/recover approach I can get an output like the following: runtime.SliceError{errorString:"slice bounds out of range", Slice:<nil>, Start:10, End:6, ErrorKind:2} Here I was trying to slice an array of length six to the 10th position. It resulted in the second check failing and there is an error putting the slice ptr onto the stack (it is formatted as nil). From my point of view this is a lot more helpful that printing “slice bounds out of range” (writing foo and printing the line number would already point to the slice). What is next? So the proof of concept works but the issue is that a more code is generated. This includes setting up the stack for the code and one error path per check emitted. I don’t think it is practical for upstream Go code. It might be useful behind a debug flag. What I think would be useful is to have a like concept that allows to access data as well. This way an error handler could extract the slice and bounds from the stack or registers. What do you think and how do you debug your go programs? How do you capture bad data in production? lot panicslice thisContext

Stories, News & Mentions about PANOSLICE

Panoslice’s Stories on HackerNoon