aleixmorgadas

Linux

How to enable function keys

echo 0 | sudo tee /sys/module/hid_apple/parameters/fnmode

Interesting Links

https://blog.colinwaddell.com/keychron-function-keys-configuration/

WEEFAA

import { NextApiHandler, NextApiRequest, NextApiResponse } from "next"

// checkout NextJS 'NextApiResponse' generic,
// TL;DR 
// calling response.send & response.json can be type, NextApiResponse<your_interface_or_type>
interface API_Response {
  ok: boolean,
  status?: number,
  data?: any
}

mfellner

import { ApolloServer, gql } from 'apollo-server-micro';

const typeDefs = gql`
  type Query {
    sayHello: String
  }
`;

const resolvers = {
  Query: {

OutThisLife

import withData from '@/lib/withData'
import { ApolloClient } from 'apollo-boost'
import App, { AppProps, Container } from 'next/app'
import { ApolloProvider } from 'react-apollo'

export default withData(
  class extends App<MyAppProps> {
    public static async getInitialProps({ Component, ...ctx }) {
      let pageProps = {}

thehappybug

type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;

export function withAppContext<
  P extends { appContext?: AppContextInterface },
  R = Omit<P, 'appContext'>
  >(
  Component: React.ComponentClass<P> | React.StatelessComponent<P>
  ): React.SFC<R> {
  return function BoundComponent(props: R) {
    return (

thiagodebastos

const grandParent = document.getElementById("grandParent")
const parent = document.getElementById("parent")
const counter = document.getElementById("counter")
let count = 0

function increaseCounter(event) {
  event.preventDefault()
  // if we don't stop propagation, the this function will run on both event listeners, thus increasing count by 2
  // event.stopPropagation()
  count += 1

tiarebalbi

Document for the best design choices you can make for your software.

Terminology

• DDD - [Domain Driven Design][ddd-wikipedia]
• FF or FTF - Function First Design, or File-type First Design is structuring your application by it's function before the files such as a directory named components containing all component files.

File Structure

Structuring applications is hard, here are a few resources to help.

remy

import { withRouter } from 'next/router';
import Link from 'next/link';
import React, { Children } from 'react';

const ActiveLink = ({ router, children, ...props }) => {
  const child = Children.only(children);

  let className = child.props.className || '';
  if (router.pathname === props.href && props.activeClassName) {
    className = `${className} ${props.activeClassName}`.trim();

manasthakur

Using git-submodules to version-control Vim plugins

If you work across many computers (and even otherwise!), it's a good idea to keep a copy of your setup on the cloud, preferably in a git repository, and clone it on another machine when you need. Thus, you should keep the .vim directory along with your .vimrc version-controlled.

But when you have plugins installed inside .vim/bundle (if you use pathogen), or inside .vim/pack (if you use Vim 8's packages), keeping a copy where you want to be able to update the plugins (individual git repositories), as well as your vim-configuration as a whole, requires you to use git submodules.

Creating the repository

Initialize a git repository inside your .vim directory, add everything (including the vimrc), commit and push to a GitHub/BitBucket/GitLab repository:

cd ~/.vim

jherax

type FilterOperator = 'AND' | 'OR';
type FiltersBy<T> = {
  [K in keyof T]?: (value: T[K]) => boolean;
};

/**
 * Factory function that creates a specialized function to filter
 * arrays, by validating all filters (AND operator),
 * or validating just one of the filters (OR operator).
 * @param operator Method to validate all filters: AND, OR