金宝搏网址开源——彭博科技188金宝搏怎么反水 //www.gillanihygienic.com 188金宝搏怎么反水 星期五,30 Apr 2021 12:43:50 +0000 en - us 每小时 1. 通过“左移”支持Python社区 //www.gillanihygienic.com/blog/supporting-the-python-community-by-shifting-left/ 彭博 Tue, 13 Apr 2021 15:00:22 +0000 //www.gillanihygienic.com/blog/supporting-the-python-community-by-shifting-left/ 彭博社正在向Python软件基金会(PSF)提供一笔赠款,资助一个全职项目。社区经理Python包装生态系统< / p > < p > post < rel =“nofollow”href = " //www.gillanihygienic.com/blog/supporting-the-python-community-by-shifting-left/ " >支持Python社区& # 8220;改变左# 8221;< / >第一次出现在< rel =“nofollow”href = " //www.gillanihygienic.com " >科技在彭博< / >。< / p >188金宝搏怎么反水








当一个组织在其SDLC中产品包含第三方软件?使用供应商提供的软件https://assets.bbhub.io/company/sites/40/2021/03/PSF-image3-1024x378.jpg“class=”attachment large size large“alt=”第三方软件供应商接受质量保证责任“srcset=”https://assets.bbhub.io/company/sites/40/2021/03/PSF-image3-1024x378.jpg 1024w,https://assets.bbhub.io/company/sites/40/2021/03/PSF-image3-300x111.jpg 300w,https://assets.bbhub.io/company/sites/40/2021/03/PSF-image3-768x284.jpg 768w,https://assets.bbhub.io/company/sites/40/2021/03/PSF-image3-1536x567.jpg 1536w, https://assets.bbhub.io/company/sites/40/2021/03/PSF-image3-170x63.jpg 170w,https://assets.bbhub.io/company/sites/40/2021/03/PSF-image3-140x52.jpg 140w,https://assets.bbhub.io/company/sites/40/2021/03/PSF-image3.jpg 1999w“尺寸=”(最大宽度:1024px)100vw,1024px“/>



Another option is to ensure that all third-party software used in the product is sourced from a vendor who has curated it from other third-parties, and who will accept the responsibility for quality assurance. This also allows the obligation to be delegated to the vendor, and is a path that even more companies choose.

Using Community-Provided Software

Organization consuming the third-party open source software must find ways to ensure that its usage of this software meets its own requirements for quality assurance

A third, very popular option is to use third-party software sourced from public communities, typically large open source software communities such as the Apache Software Foundation, the Python Software Foundation, the Linux Foundation, and similar non-profit organizations. Unfortunately, this does not allow the obligation for quality assurance to be delegated, because the community isn't able to accept that responsibility; the organization consuming the software must find ways to ensure that its usage of this software meets its own requirements for quality assurance.

Quality Assurance for Community-Provided Software

This leaves the organization with a bit of a dilemma; they still must find ways to assure quality in their SDLC, but some of the 'inputs' into their product are not already quality-assured.

Bloomberg is such an organization; we use a large amount of community-provided open source software, and it comes from a number of communities. Surveys of those communities demonstrate that their ability to attest to various aspects of 'quality' in the software they publish varies greatly:

  • Many communities do not use digital signatures to verify package authenticity
  • Many communities do not provide mechanisms to assure that package names respect branding
  • Many communities do not require all published packages to be produced on 'controlled' build systems

Because of this variety, it is challenging to create a 'minimum standard' set of requirements for the software that we use. To address this, we want to help these communities improve their ability to attest to the quality of the software that they provide.

Supporting the Python community by "Shifting Left"

This help will take many forms, but for the Python Software Foundation (PSF), it means that we've committed to providing two years of funding for a full-time Project & Community Manager for the Python Packaging ecosystem. We were thrilled to learn that the PSF had already been considering this concept when we approached them to find out what we could do to help, and that they have given us the opportunity to collaborate with them to address this important need.

We're also happy to see that the Python ecosystem will benefit from a recent NSF grant that was awarded to NYU, which is specifically targeted at improving security in packaging. We expect the soon-to-be-hired Project/Community Manager will be involved in facilitating this work too.

Of course, we'll also continue to provide code (some of our team members are involved in Warehouse, pip, setuptools, and other projects across the Python packaging ecosystem) and engage in PEP processes to help the community make decisions about improvements to Python packaging. We encourage our peers in the technology community, who also use Python and its community-provided packages, to join these efforts so that the entire community will benefit.

This means that when Bloomberg 'shifts left' and reaches the 'community-provided' fork in the Development stage of our SDLC, we'll be doing everything we can to improve quality assurance -- for us and for every other user of Python. Thanks to PSF Fellow Mario Corchero, who leads Bloomberg's Python Infrastructure team, for putting things in motion to make this happen. Thanks also to Ewa, Ee, Dustin, and everyone else at the PSF, who have been fantastic partners.

The post Supporting the Python community by “Shifting Left” appeared first on Tech At Bloomberg.

彭博社的研究人员发布了kōan,使CBOW的实施更快、更准确 //www.gillanihygienic.com/blog/bloomberg-researchers-publish-koan-making-cbow-implementations-faster-and-more-accurate/ 彭博 2021年1月4日星期一14:53:57+0000 //www.gillanihygienic.com/blog/bloomberg-researchers-publish-koan-making-cbow-implementations-faster-and-more-accurate/

" kōan: A Corrected CBOW Implementation "是一份技术报告,详细介绍了我们的人工智能研究人员使用该实现进行单词嵌入的实验,该报告已在arXiv上发表。

The post Bloomberg研究人员发布kōan,首先出现在Tech At Bloomberg.

2020年初,彭博社的两位人工智能研究人员,Adrian Benton和Ozan İrsoy,正在进行更有效的上下文词嵌入的研究,


他们的技术报告,“kōan: A Corrected CBOW Implementation”,其中详细介绍了他们的实验,已经在arXiv上发表了< A href="https://arxiv.org/abs/2012.15332" target="_blank" rel="noopener noreferrer">。

它们的实现代码现在可以在GitHub上获得:http://github.com/bloomberg/koan. " />

making CBOW implementations faster and more accurate appeared first on Tech At Bloomberg.

大规模采用TypeScript的10点启示 //www.gillanihygienic.com/blog/10-insights-adopting-typescript-at-scale/ 彭博 Tue, 10 Nov 2020 04:56:30 +0000 //www.gillanihygienic.com/blog/10-insights-adopting-typescript-at-scale/ < p >见解& # 38;

The post href = " https://www.techatbloomberg.co188金宝搏怎么反水m " >科技在彭博< / >。< / p >

作者:Rob Palmer,JavaScript基础设施和;几年前,彭博资讯工程部决定采用https://www.typescriptlang.org/“target=“\u blank”rel=“noopener noreferrer”>TypeScript作为一流的受支持语言。这篇文章分享了我们在这段旅程中所学到的一些见解和教训。

标题是我们发现TypeScript是一个强大的积极因素!当阅读我们探索的一些令人惊讶的角落时,请记住这一点。作为工程师,我们很自然地被吸引去发现、解决和分享问题,即使我们玩得很开心https://s.w.org/images/core/emoji/12.0.0-1/72x72/1f609.png“alt=”“class=“wp smiley”style=“高度:1米;最大高度:1米;”/>






除了规模之外,TypeScript集成的独特之处在于我们有自己的JavaScript运行时环境。这意味着,除了众所周知的JavaScript主机环境,如浏览器和节点,我们还直接嵌入V8引擎和Chromium来创建我们自己的JavaScript平台。这种情况的好处是,我们可以提供一种简单的开发人员体验,其中TypeScript由我们的平台和包生态系统直接支持。Ryan Dahl的Deno通过将TypeScript编译放入运行时来追求类似的想法,而我们将其保存在独立于运行时进行版本控制的工具中。一个有趣的结果是,我们开始探索在一个独立的JS环境中使用TypeScript编译器是什么样子的,该环境跨客户端和服务器,并且不使用特定于节点的约定(例如,没有节点模块目录).





可扩展性:开发速度应为kept high as more packages adopt TypeScript. Time spent installing, compiling, and checking code should be minimized.

☮ Ecosystem Coherence: Packages should work together. Upgrading dependencies should be pain-free.

Standards Alignment: We want to stick with standards, such as ECMAScript, and be ready for where they might go next.

The discoveries that surprised us usually came down to cases where we weren't sure if we could preserve these principles.

10 Learning Points

1. TypeScript can be JavaScript + Types

Over the years, the TypeScript team has actively pursued the adoption of and alignment with standard ECMAScript syntax and runtime semantics. This leaves TypeScript to concentrate on providing a layer of type syntax and type-checking semantics on top of JavaScript. The responsibilities are clearly separated: TypeScript = JavaScript + Types!

This is a wonderful model. It means that the compiler output is human-readable JavaScript, just like the programmer wrote. This makes debugging production code easy even if you don't have the original source code. It means you do not need to worry that choosing TypeScript might cut you off from future ECMAScript features. It leaves the door open to runtimes, and maybe even future JavaScript engines, that can ignore the type syntax and therefore "run" TypeScript natively. A simpler developer experience is in sight!

Along the way, TypeScript was extended with a small number of features that don't quite fit this model. enum, namespace, parameter properties, and experimental decorators all have semantics that require them to be expanded into runtime code that, in all likelihood, will never be directly supported by JavaScript engines.

Standards Alignment ❔

This is not a big deal. The TypeScript Design Goals articulate the need to avoid introducing more runtime features in the future. One member of the TypeScript team, Orta, created a meme-slide to emphasize this recognition.One member of the TypeScript team, Orta, created a meme-slide to emphasize the need to avoid introducing more runtime features in the future (as per the TypeScript Design Goals).

Our toolchain addresses this set of undesirable features by preventing their use. This ensures that our growing TypeScript codebase is truly JS + Types.

Standards Alignment ✔

2. Keeping up with the Compiler is worthwhile

TypeScript evolves rapidly. New versions of the language introduce new type-level features, add support for JavaScript features, improve performance and stability, as well as improve the type-checker to find more type errors. So there's a lot of enticement to use new versions!

Whilst TypeScript strives to preserve compatibility, these type-checking improvements represent breaking changes to the build process as new errors are identified in codebases that previously appeared error-free. Upgrading TypeScript therefore requires some intervention to get these benefits.

There is another form of compatibility to consider, which is inter-project compatibility. As both JavaScript and TypeScript syntaxes evolve, declaration files need to contain new syntax.

If a library upgrades TypeScript and starts producing modern declaration files with new syntax, application projects using that library will fail to compile if their version of TypeScript does not understand that syntax. An example of new declaration syntax is the emit of getter/setter accessors in TypeScript 3.7. These are not understood by TypeScript 3.5 or earlier. This means that having an ecosystem of projects using different compiler versions is not ideal.

☮ Ecosystem Coherence ❔

At Bloomberg, codebases are spread across various Git repositories that use common tooling. Despite not having a monorepo, we do have a centralized registry of TypeScript projects. This allowed us to create a Continuous Integration (CI) job to "build the world" and verify the build-time and run-time effects of compiler upgrades on every TypeScript project.

This global checking is very powerful. We use this to assess Beta and RC releases of TypeScript to discover issues ahead of general release. Having a diverse corpus of real-world code means we also find edge cases. We use this system to guide fix-ups to projects ahead of the compiler upgrade, so that the upgrade itself is flawless. So far, this strategy has worked well and we have been able to keep the entire codebase on the latest version of TypeScript. This means we have not needed to employ mitigations such as downlevelling DTS files.

☮ Ecosystem Coherence ✔

3. Consistent tsconfig settings are worthwhile

Much of the flexibility provided by tsconfig is to allow you to adapt TypeScript to your runtime platform. In an environment where all projects are targeting the same evergreen runtime, it turns out to be a hazard for each project to configure this separately.

☮ Ecosystem Coherence ❔

Therefore we made our toolchain responsible for generating tsconfig at build time with "ideal" settings. For example, "strict" mode is enabled by default to increase type-safety. "isolatedModules" is enforced to ensure our code can be compiled quickly by simple transpilers that operate on a single file at a time.

A further benefit of treating tsconfig as a generated file, rather than as a source file, is that it permits higher-level tooling to flexibly link together multi-project "workspaces" by taking responsibility for defining options such as "references" and "paths".

There is some tension here, as a minority of projects wanted the ability to make customizations such as switching to looser modes to reduce the migration burden.

Initially we tried to cater to these requests and gave access to a small number of options. Later we found that this resulted in inter-package conflicts, when declaration files built using one set of options were consumed by a package using different options. Here's one example.

It's possible to create a conditional type that is directed by the value of "strictNullChecks".

type A = unknown extends {} ? string : number;

If "strictNullChecks" are enabled, then A is a number. If "strictNullChecks" are disabled, then A is a string. This code breaks if the package exporting this type is not using the same strictness settings as the package importing it.

This is a simplified example of a real-life issue we faced. As a result, we chose to deprecate the flexibility on strictness modes in favour of having consistent configs for all projects.

☮ Ecosystem Coherence ✔

4. How you specify the location of dependencies matters

We needed the ability to explicitly declare the location of our dependencies to TypeScript. This is because our ES module system does not rely on the Node file-system convention of finding dependencies by walking up a series of directories named node_modules.

We needed the ability to declare a mapping of bare-specifiers (e.g., "lodash") to directory locations on disk ("c:\dependencies\lodash"). This is similar to the problem that import maps attempt to solve for the Web. At first, we tried using the "paths" option in tsconfig.

// tsconfig.json "paths": { "lodash": [ "../../dependencies/lodash" ]  }

This worked great for nearly all use cases. However, we discovered this degraded the quality of generated declaration files. The TypeScript compiler necessarily injects synthetic import statements into declaration files to allow for composite types - where types can depend on types from other modules. When the synthetic imports reference types in dependencies, we found the "paths" approach injected a relative path (import("../../dependencies/lodash")) rather than preserving the bare-specifier (import "lodash"). For our system, the relative location of external package typings is an implementation detail that may change, so this was unacceptable.

☮ Ecosystem Coherence ❔

The solution we found was to use Ambient Modules:

// ambient-modules.d.ts declare module "lodash" { export * from "../../dependencies/lodash"; export default from "../../dependencies/lodash"; }

Ambient Modules are special. TypeScript's declaration-emit preserves references to them rather than converting them to a relative path.

☮ Ecosystem Coherence ✔

5. De-duplicating types can be important

App performance is critical, so we try to minimize the volume of JS that apps load at runtime. Our platform ensures that only one version of a package is used at runtime. This de-duplication of versions means that a given package cannot "freeze" or "pin" their dependencies. Consequently, this means packages must preserve compatibility over time.

We wanted to provide the same "exactly-one" guarantee for types to ensure that, for a given compilation of a project, the type-check would only ever consider one single version of a package’s dependencies. In addition to compile-time efficiency, the motivation was to ensure the type-checked world better reflects the runtime world. We specifically wanted to avoid staleness issues and "nominality hell," in which two incompatible versions of nominal types are imported via a "diamond pattern". This is a hazard that will likely grow as ecosystem adoption of nominal types increases.

⚖ Scalability ❔

☮ Ecosystem Coherence ❔

We wrote a deterministic resolver that selects exactly one version of each dependency to type against based on the declared version constraints of the package being built.

⚖ Scalability ✔

☮ Ecosystem Coherence ✔

This means the graph of type dependencies is dynamically assembled - it is not frozen. Whilst this unpinned dependency approach provides benefits and avoids some hazards, we later learned that it can introduce a different hazard due to subtle behavior in the TypeScript compiler. See 9. Generated declarations can inline types from dependencies to learn more.

These trade-offs and choices are not specific to our platform. They apply equally to anyone publishing to DefinitelyTyped/npm, and are determined by the aggregate effect of each package's version constraints expressed in package.json "dependencies".

6. Implicit Type Dependencies should be avoided

It's easy to introduce global types in TypeScript. It's even easier to depend on global types. If left unchecked, this means it is possible for hidden coupling to occur between distant packages. The TypeScript Handbook calls this out as being "somewhat dangerous."

⚖ Scalability ❔

☮ Ecosystem Coherence ❔

// A declaration that injects global types declare global { interface String {  fancyFormat(opts?: StringFormatOptions): string;  } } // Somewhere in a file far, far away... String.fancyFormat(); // no error!

The solution to this is well-known: prefer explicit dependencies over global state. TypeScript has provided support for ECMAScript import and export statements for a long time, which achieve this goal.

So the only remaining need was to prevent accidental creation of global types. Thankfully, it is possible to statically detect each of the cases where TypeScript permits the introduction of global types. So, we were able to update our toolchain to detect and error in the cases where these are used. This means we can safely rely on the fact that importing a package's types is a side-effect-free operation.

⚖ Scalability ✔

☮ Ecosystem Coherence ✔

7. Declaration files have three export modes 

Not all declaration files are equal. A declaration file operates in one of three modes, depending on the content; specifically the usage of import and export keywords.

  1. global -- A declaration file with no usage of import or export will be considered to be global. Top-level declarations are globally exported.
  2. module -- A declaration file with at least one export declaration will be considered to be a module. Only the export declarations are exported and no globals are defined.
  3. implicit exports -- A declaration file that has no export declarations, but does use import will trigger defined-yet-undocumented behaviour. This means that top-level declarations are treated as named export declarations and no globals are defined.

We do not use the first mode. Our toolchain prevents global declaration files (see previous section: 6. Implicit Type Dependencies should be avoided). This means all declaration files use ES module syntax.

⚖ Scalability ✔

Ecosystem Coherence ✔

Standards Alignment ✔

Perhaps surprisingly, we found the slightly-spooky third-mode to be useful. By adding just a single-line self-import to the top of ambient declaration files, you can prevent them from polluting the global namespace: import {} from "./<my-own-name>";. This one-liner made it trivial to convert third-party declarations, such as lib.dom.d.ts, to be modular and avoided the need to maintain a more complex fork.

The TypeScript team do not seem to love the third-mode, so consider avoiding it where possible.

8. Encapsulation of Packages can be violated

As explained earlier (in 5. De-duplicating types can be important), our use of unpinned dependencies means it is important for our packages to preserve not only runtime-compatibility, but also type-compatibility over time. That's a challenge, so to make this preservation of compatibility practical, we have to really understand which types are exposed and must be constrained in this way. A first step is to explicitly differentiate public vs. private modules.

Node recently gained this capability in the form of the package.json "exports" field. This defines an encapsulation boundary by explicitly listing the files that are accessible from outside the package.

Today, TypeScript is not aware of package exports and so does not have the concept of which files within a dependency are considered public or not. This becomes a problem during declaration generation, when TypeScript synthesizes import statements to transitive types in the emitted .d.ts file. It is not acceptable for our .d.ts files to reference private files in other packages. Here's an example of it going wrong.

// index.ts import boxMaker from "another-package" export const box = boxMaker();

The above source can lead to tsc emitting the following undesirable declaration.

// index.d.ts export const box : import("another-package/private").Box

This is bad because "another-package/private" is not part of that package's compatibility promise, so might be moved or renamed without a SemVer major bump. TypeScript today has no way of knowing it generated a fragile import.

☮ Ecosystem Coherence ❔

We mitigate this problem using two steps:

1. Our toolchain informs the TypeScript resolver of the intentionally-public bare-specifier paths that point to dependencies (e.g., "lodash/public1", "lodash/public2"). We ensure TypeScript knows about the full set of legitimate dependency entry-points by silently adding type-only import statements to the bottom of the TypeScript files just before they flow into the compiler.

// user's source code // injected by toolchain to assist declaration emit import type * as __fake_name_1 from "lodash/public1"; import type * as __fake_name_2 from "lodash/public2";

When generating references to inferred transitive types, TypeScript's declaration emit will prefer to use these existing namespace identifiers rather than synthesizing imports to private files.

2. Our toolchain generates errors if TypeScript generates a path to a file in a dependency that we know is private. This is analogous to the existing TypeScript errors emitted when TypeScript realizes that it is generating a potentially hazardous path to a dependency.

error TS2742: The inferred type of '...' cannot be named without a reference to '...'. This is likely not portable. A type annotation is necessary. 

This informs the user to work around the issue, by explicitly annotating their exports. Or, in some cases, they need to update the dependency to publicise internal types by directly exporting them from a public package entrypoint.

☮ Ecosystem Coherence ✔

We look forward to TypeScript gaining first-class support for entrypoints so that workarounds like this are unnecessary.

9. Generated declarations can inline types from dependencies

Packages need to export .d.ts declarations so that users can consume them. We choose to use the TypeScript declaration option to generate .d.ts files from the original .ts files. Whilst it's possible to hand-write and maintain .d.ts sibling files alongside regular code, this is less preferable because it is a hazard to keep them synchronized.

TypeScript's declaration emit works well most of the time. One issue we found was that sometimes TypeScript will inline types from a dependency into the generated types (#37151). This means the type definition is relocated and potentially duplicated, rather than being referenced via an import statement. With structural typing, the compiler is not compelled to ensure types are referenced from one definition site - duplication of these types can be ok.

We have seen extreme cases where this duplication has inflated declaration files from 7KB to 700KB. That's quite a lot of redundant code to download and parse.

 ⚖ Scalability ❔

Inlining of types within a package is not an ecosystem problem, because it is not externally visible. It becomes problematic when types are inlined across package boundaries, because it couples those two specific versions together. In our unpinned package system, packages can evolve independently. This means there is a risk of type incompatibility and, in particular, a risk of type staleness.

☮ Ecosystem Coherence ❔

Through experimentation, we discovered potential techniques to prevent inlining of type declarations, such as:

⚖ Scalability

 ☮ Ecosystem Coherence

The inlining behaviour does not seem to be strictly specified. It is a side-effect of the way declaration files are constructed. So, the above methods may not work in future. We hope this is something that can be formalized in TypeScript. Until then we shall rely on user education to mitigate this risk.

10. Generated Declarations can contain non-essential dependencies

Consumers of TypeScript declaration files typically only care about the public type API of a package. TypeScript declaration emit generates exactly one declaration file for every TypeScript file in a project. Some of this content can be irrelevant to users and can expose private implementation details. This behavior can be surprising to newcomers to TypeScript, who expect the typings to be a representation of the public API like the handwritten typings found on Definitely Typed.

One example of this is generated declarations including typings for functions used only for internal testing.

 ⚖ Scalability ❔


Since our package system knows all the public package entrypoints, our tooling can crawl the graph of reachable types to identify all the types that do not need to be made public. This is Dead Type Elimination (DTE) or more precisely, Tree-Shaking. We wrote a tool to do this - it performs minimal work by only eliminating code from declaration files. It does not rewrite or relocate code - it is not a bundler. This means the published declarations are an unchanged subset of the TypeScript-generated declarations.

Reducing the volume of published types has several advantages:

  • it decreases the coupling to other packages (some packages do not re-export types from their dependencies)
  • it aids encapsulation by preventing fully-private types from leaking
  • it decreases the count and size of the published declaration files that need to be downloaded and unpacked by users
  • it decreases the volume of code the TypeScript compiler has to parse when type-checking

The "shaking" can have a dramatic effect. We've seen several packages where >90% of the files and >90% of the lines of types can be dropped.

 ⚖ Scalability ✔

Some options have sharp edges

We found a few surprises in the semantics of some of the tsconfig options.

Mandated baseUrl in tsconfig

In TypeScript 4.0. if you want to use Project References or "paths", you are required to also specify a baseUrl. This has the side effect of causing all bare-specifier imports to resolve relative to your project's root directory.

// package-a/main.ts import "sibling" // Will auto-complete and type-check if `package-a/sibling.js` exists

The hazard is that if you want to introduce any form of "paths", it carries the additional implication that import "sibling" will be undesirably interpreted by TypeScript as an import of <project-root>/sibling.js from inside your source directory.

Standards Alignment ❔

To work around this, we used an unspeakable baseUrl. Using a null character prevents the undesirable bare auto-completions. We don't recommend you try this at home.

We reported this on the TypeScript issue tracker and were thrilled to see that Andrew has solved this for TypeScript 4.1, which will enable us to say goodbye to the null character!

Standards Alignment ✔

JSON modules imply synthetic default imports

If you want to use "resolveJsonModules", you are required to also enable "useSyntheticDefaultImports" in order for TypeScript to see the JSON module as a default import. Using default imports is likely to become the way that Node and the Web handle JSON modules in future.

Enabling "useSyntheticDefaultImports" has the unfortunate consequence of artificially allowing default imports from regular ES modules that do not have a default export! This is a hazard that you will only find out about when you come to run the code and it quickly falls over.

Standards Alignment ❔

Ideally, there should be a way to import JSON modules that does not involve globally enabling synthetic defaults.

The Great Parts

It's worth calling out some of the particularly good things we've seen from TypeScript along the way from a tooling perspective.

Incremental builds have been essential. API support for incremental builds was a huge boost to us in TypeScript 3.6, allowing custom toolchains to have fast rebuilds. After we reported a performance issue when combining incremental with noEmitOnError, Sheetal made them even faster in TypeScript 4.0.

 ⚖ Scalability ✔

"isolatedModules" was vital to ensure we can perform fast standalone (one in, one out) transpilation. The TypeScript team fixed a bunch of issues to improve this option including:

 ⚖ Scalability ✔

☮ Ecosystem Coherence ✔

Project References are the key to providing a seamless IDE experience. We leverage them greatly to make multi-package workspace-based development as slick as single-project development. Thanks to Sheetal, they are now even better and support file-less "solution-style" tsconfigs.

 ⚖ Scalability ✔

Type-only imports have been super useful. We use them everywhere to safely distinguish runtime imports from compile-time imports. They are essential for certain patterns using "isolatedModules" and allowed us to use "importsNotUsedAsValues": "error" for maximum safety. Thanks to Andrew for delivering this!

☮ Ecosystem Coherence ✔

Standards Alignment ✔

"useDefineForClassFields" was important for ensuring our emitted ESNext code does not get rewritten, preserving the JS + Types nature of the language. It means we can natively use Class Fields. Thanks to Nathan for providing this and making the migration process as smooth as possible.

Standards Alignment ✔

Feature delivery in TypeScript has been very fortuitous. Each time we realized we needed a feature, we frequently discovered it was already being delivered in the next version.


The end result is that TypeScript is now a first-class language for our application platform. Integrating TypeScript with yet-another-runtime shows that the language and compiler seems to be just as flexible as JavaScript - they can both be used pretty much anywhere.A JavaScript box exploding to reveal TypeScript inside.


Many thanks for the reviews from Thomas Chetwin, Robin Ricard, Kubilay Kahveci, Scott Whittaker, Daniel Rosenwasser, Nathan Shively-Sanders, Titian Dragomir, and Maxwell Heiber. And thanks to Orta for the Twoslash code-formatting.

The Banana & Box graphics were created by Max Duluc.

The post 10 Insights from Adopting TypeScript at Scale appeared first on Tech At Bloomberg.

与团队会面:SF工程部 //www.gillanihygienic.com/blog/meet-the-teams-sf-engineering/ 彭博 2020年10月29日星期四22:49:06+0000 //www.gillanihygienic.com/blog/meet-the-teams-sf-engineering/ 在彭博成长中的旧金山办公室软件工程师的许多项目中,都非常关注开源的使用。

< P>帖子Re=“NoFoLoLy”HReF=//www.gillanihygienic.com/blog/meet-the-teams-sf-engineering/“>与团队会金宝搏网址面:SF Engineering首先出现在彭博资讯科技公司


我们会见彭博旧金山工程办公室负责人。 < B> < Mario Cadete > < /b> < i>“三年前从伦敦迁到旧金山工程队,在这段时间里,它已经从25人增加到80人。”

< P> < B>告诉我们你作为SF工程负责人的角色。< B/> < StopyType =“字体权重:400”>


< P> < Bloomberg工程自2015以来一直在旧金山。是什么因素促使我们向该地区扩张?
我们在这里构建的下一代平台是用开源软件构建的。我们通过利用湾区的专业知识和基于云的技术,如Kubernetes和类似的编程语言="https://www.python.org/“target=“\u blank”rel=“noopener noreferrer”>PythonJavaScript. 我们之所以吸引新员工的注意力,是因为彭博社是开源项目的积极贡献者,如Jupyter项目Apache-Kafka,以及https://spark.apache.org/“target=“\u blank”rel=“noopener noreferrer”>Apache Spark < P> < B>旧金山办公室的文化是什么?跨度样式=“字体权重:400”>BR/>我创造了一个社会、协作和大学的环境。我会亲自面试每一位SF工程师候选人,因为我想建立一种关系,并解释什么对我和我们作为一个办公室来说都很重要。我们的文化建立在相互关心对方成功的基础上。从我们的工程师上船的那一天起,就有很多援助之手为他们提供支持。这体现在同事们自由分享他们的时间和专业知识,以及他们建立的社区,体现在我们的多样性和包容性,体现在彭博社对慈善事业的深刻承诺上。

In addition, we care about our own development as well. Bloomberg offers a broad catalog of training, from technical training to financial markets courses to leadership and communication programs. In SF, we go beyond that, also offering courses in machine learning and cloud technologies like Docker and Kubernetes. And we also offer workshops on storytelling and using the art of improv to improve communication skills and foster team building.

You’re very active in supporting Bloomberg Engineering’s diversity & inclusion initiatives. Talk about your role as a male ally and what inspires your enthusiastic advocacy for creating a more inclusive work environment.
After 20 years in the industry, I've seen times where there hasn’t been much diversity on teams, whether it's race, gender, or even academic credentials. SF Engineering has a very diverse workforce, and we want to make it even more diverse with each new hire. Even more importantly, I think that everybody deserves a chance to succeed. We have a responsibility to be role models for people — both internally and externally — who don't realize what's possible.

I want to give opportunities to the best people. I see I'm in a fortunate position, and I'm also aware of the privilege that is associated with it. Because of this, I view myself as someone who can provide a bridge to opportunity for those who may not have had access in the past. It's important to foster an inclusive work environment here at Bloomberg because it allows us to attract great engineers and to have our engineers collaborate in a place where they can achieve impactful results.

How do you foster culture on your team?
Before the pandemic, I didn’t realize how much time I spent on small interactions and touchpoints in which I was getting feedback and questions in an informal, almost accidental way, and building stronger relationships. Our culture is underpinned by really candid, effective communication. Whether at the office or working from home, I always try to lead by example to be an active listener, supportive, and transparent. I try to model a work ethic that’s not about hours, but about quality and balance for one’s mental health.

"We attract the attention of new recruits because Bloomberg is a very active contributor to open source projects like Project Jupyter, Apache Kafka, and Apache Spark."

– Mario Cadete

Anne Zepecki

Anne Zepecki is a relatively new addition to the SF Engineering team, having joined about a year ago. Here she shares her story of experiencing Bloomberg’s rather unique interview process.  

You earned your CS degree in May 2019 and started full-time with Bloomberg last September. Tell us about the path that got you here.
My path to my current role at Bloomberg began in the fall of 2017, when I heard about Bloomberg through the
National Center for Women & Information Technology (NCWIT), a group I first became involved with in high school. NCWIT shared Bloomberg job postings with the community and, after reading more about the firm, I became interested in how tech plays a role in finance. I decided to apply for the internship program. My on-site interview with Bloomberg stood out to me, as it was actually the first time I had ever been interviewed by a female engineer. In this case, I was interviewed by two. Many companies like to boast about how they support diversity and support women in tech specifically, but then you’re at the on-site, and you look around, and you don’t see that reflected in the workforce. When I came to Bloomberg and actually met female engineers (and as my interviewers!), this immediately signaled that Bloomberg was different. 

My summer experience as an intern challenged me technically, but in a way that left me wanting to continue to solve the same sorts of fascinating problems after graduation. Community played a big role in my desire to return to Bloomberg, too — my colleagues were amazing, and I was excited to work with them and learn from them everyday. As an intern, I heard about the San Francisco office and the work that was going on out here, and I was lucky enough to connect with my current team. I was especially excited about Bloomberg’s involvement in the local tech ecosystem. 

What are you working on now, and what open source technologies are you using?
My team is building out a Kubernetes-based data analysis development platform. We work with lots of different open source technologies, especially given that our product is derived from JupyterLab. My team heavily uses Kubernetes and Docker. Within the SF office, we have a lot of engineers who contribute regularly to the open source community.

What do you wish you knew about software engineering careers before you joined Bloomberg?
I wish I had learned more about how to take all the pieces of a system and put them together when I was in college! In classes, it’s easy to focus on more isolated components, so when you get to a real-world system, you have to adjust to the mindset where you take a step back and think about problems from an architectural and systems point of view. 

What should new recruits know about the impact they can make at Bloomberg?
The great thing about Bloomberg is that because the culture is so inclusive and welcoming by nature, it’s really easy to get involved in the community and make an impact in your role right away. A few months back, I had the idea to create a discussion and reading group to bring together our employee resource groups here in San Francisco to speak about identity and intersectionality — and in the last few months, I’ve had the chance to bring this initiative to life. It is the enthusiasm and support of my colleagues that made this possible.

I also was fortunate enough to present an internal talk with one of my teammates to our Automated Testing Guild. It was wonderful to get to share some of the work my team is doing with others in the company, and it was a really cool experience for me to be able to do something like this less than a year into my full-time career.

"Many companies like to boast about how they support diversity and support women in tech specifically, but then you’re at the on-site, and you look around, and you don’t see that reflected in the workforce. When I came to Bloomberg and actually met female engineers (and as my interviewers!), this immediately signaled that Bloomberg was different."

– Anne Zepecki

Biju Nair

Distributed Systems Engineer Biju Nair joined Bloomberg just as the company began to seriously invest in open source, an effort that has only expanded.

You’ve been an engineer for more than 20 years. Tell us a little bit about your career path.
My interest in systems programming from school -- along with the opportunity to work with senior engineers and researchers in data storage, information retrieval, and messaging and transaction processing systems -- helped build a good foundation. From then on, all my work kept me current in these areas, while also helping large enterprises. When presented with an opportunity, I moved to the San Francisco office from the East Coast to work in the streaming data processing domain, and also to escape the cold weather! The move was seamless since internal mobility is the norm at Bloomberg. 

What are you working on now?
Being able to process and derive insights from data-in-motion in real time is valuable to many Bloomberg products. Our team provides a platform that simplifies building such features. We use open source technologies like Apache Kafka, Kafka Streams, Kafka Connect, Apache Flink, and Kubernetes as our basic building blocks. It is always inspiring when a product team showcases what was built using our platform and how it helps their users.

What are some of the unique technical challenges associated with serving up financial data sets to Bloomberg’s clients millions of times a day?
Since Bloomberg’s products and services are used to serve capital markets data to major financial institutions and decision makers across the globe, we can’t compromise when it comes to low latency, high availability, scalability, and security. These factors influence our design, development, and deployment decisions every day.

What else would you like to share about your Bloomberg experience?
Bloomberg values that encourage doing the right thing, collaboration, and inclusion resonated with me from the start. Every day, I appreciate being able to work with some of the best engineers -- both within the organization and outside through collaborations in open source projects. To top it off, knowing that the work we do helps many philanthropic causes is incredibly satisfying.Cheryl Quah

Software Engineering Team Lead Cheryl Quah started at Bloomberg eight years ago with a bachelor’s degree in physics, but her curiosity and enthusiasm for personal growth has fueled her development towards leadership in software development.

You started your career eight years ago at Bloomberg. What first attracted you to the company?
I studied physics in school. At the time, Bloomberg was one of the few companies willing to hire new graduates into software engineering roles even if they did not have traditional computer science backgrounds. To me, this was a strong sign of how much the company was willing to invest in us and train and develop us! This has turned out to be true throughout my time here. 

In general terms, what are you working on now, and what open source technologies are you using?
Bloomberg has vast amounts of data across thousands of data sets. We are building a data analysis platform that allows our clients to use Python APIs to access these data sets and sophisticated financial analytics. This is an important paradigm shift because they can now use the tools of the scientific Python ecosystem — as well as interactive visualizations and applications — to meet their very specific research and workflow needs. They have access to much more customization and flexibility than before.

Bloomberg’s data analysis platform is built on top of the Project Jupyter ecosystem. As a company, we have funded significant initiatives in the Jupyter open source community, such as JupyterLab, Voilà, and more. I’m gratified that we are able to contribute substantially to these open source projects that are used globally.

What’s your best advice for helping your team members grow in their careers?
It’s important for each of us to own our growth and our career journeys. To me, this involves reflecting deeply on what your sources of satisfaction and motivation are, and what kinds of stretch opportunities you are looking for, knowing that all of these will likely evolve over time. Partner with your manager — help them understand what’s important to you. Being open to expressing this and being able to communicate it is how you gain agency over your own career journey, and how you can find a stronger sense of satisfaction in your work, and not just walk a path that someone else is laying out for you.

You were one of the three co-founders of the Bloomberg Women in Technology (BWIT) community in 2014. When you look at the inclusive environment for women in the Engineering department at Bloomberg today, what are you most proud of about the impact this community has had?
It’s been wonderful to see how strong the community is globally due to the hard work of its current leaders and active members, and how it serves as a channel for more than 1,100 members — both women and male allies — to meet and form strong relationships across teams and departments. When I see members exchange information, opportunities and advice, and support each other and inspire each other to reach for more, I see a network effect in action that benefits the whole company. For many of us, this sense of connection also keeps us more engaged at work.

In addition, the various Bloomberg communities (including their respective allyship initiatives), in combination with many other factors in the wider world, have contributed to a shift in the leadership dialogue to make it imperative that managers understand how to build inclusive environments.

"It’s important for each of us to own our growth and our career journeys. To me, this involves reflecting deeply on what your sources of satisfaction and motivation are, and what kinds of stretch opportunities you are looking for, knowing that all of these will likely evolve over time."

– Cheryl Quah

Kelsey Gloor

Bloomberg serves up a massive amount of multimedia content every day. Kelsey Gloor’s team helps to make that photo and video content readily searchable and accessible.

Tell us a little bit about your career path.
I have worked in multimedia for 10 years. I did not expect to stay in one area for so long, but over my seven years at the New York office, I continued to grow technically, made connections across departments, and became invested in the product and long-term vision of the team. As I grew into a leadership role, I was given the opportunity to lead a new Multimedia Management team based in San Francisco. Getting the chance to start a team in a smaller, distributed engineering office has been the most rewarding work of my career.

What are you working on now?
This year we have taken on a large cross-departmental initiative to consolidate multiple video repositories into a universal media platform. This has been a long-term goal across all of our media engineering teams at Bloomberg, and will open opportunities for growth and development via a video search engine, seamless distribution pipeline, and improved content permissioning.

Search technology is critical to every product we provide. Throughout my career here, it has been great to see Bloomberg investing in making search accessible to all teams via our Bloomberg Foundational Search team and the Search Guild for engineers across the company to get more involved externally in the open source enterprise search community. 

As a team, we use a managed instance of Apache Solr, which has enabled us to expose our archive of over 40 million media assets in a meaningful and intuitive way so clients can quickly find content relevant to them. 

What do you think a team must have to be effective and healthy, particularly during this time of disruption?
We emphasize trust, open communication, and ingenuity. We are stronger when every member of the team has ownership and is empowered to advocate for new ideas. In many ways, this difficult time and transition to remote working has actually brought our team closer together. Reggie Dugard

Senior Software Engineer Reggie Dugard has spent over 20 years in financial services. He developed an extensive knowledge of Python, which he now puts to good use at Bloomberg. 

What attracted you to Bloomberg?
Before Bloomberg, I had worked with a small hedge fund for many years, until they decided to close their California office. I enjoy the small-office culture and Bloomberg’s San Francisco office offers that same feel for me. I was also looking for a role where I could use my Python knowledge and was excited to discover that Python is a first-class language at Bloomberg.

You’re very involved in a variety of D&I Communities (employee resource groups). Tell us more about your participation and why these Communities are important to you.
I enjoy learning from people who have backgrounds and experiences different from my own. I think it makes me a better engineer to be exposed to different points of view. When I joined the company, I immediately joined BPROUD, our LGBT & Ally Community, which was very welcoming, but it took me a little while to realize that other communities, where I wasn’t part of the target group, would also welcome me as an ally. Now I’m also involved in communities like Bloomberg Women in Tech (BWIT) and Bloomberg Black In Tech (BBIT). I feel that having this exposure helps me appreciate the unique and common challenges faced by people from underrepresented groups, enabling me to be a more empathetic colleague.

Anything else you would like to share about your Bloomberg experience?
Bloomberg’s Corporate Philanthropy. I really feel good about working for a company that gives to philanthropic organizations. I also enjoy the many opportunities that are offered to volunteer for these organizations and the Dollars For Your Hours program that allows me to convert my volunteer hours into donations to non-profit organizations that I’m passionate about.Check out some of the open roles with the teams in our SF Engineering office here and here.

The post Meet the Teams: SF Engineering appeared first on Tech At Bloomberg.

bqplot现在是一个社区开源项目!金宝搏网址 //www.gillanihygienic.com/blog/bqplot-is-now-a-community-open-source-project/ 彭博 2020年4月16日星期四13:50:56+0000 Jupyter 金宝搏网址 Python //www.gillanihygienic.com/blog/bqplot-is-now-a-community-open-source-project/ 作为制作bqplot(交互式绘图和图表库,一个独立的开源项目)的第一步,我们已经将它移到了GitHub上自己的组织中。金宝搏网址

The post bqplot现在是一个社区开源项目!金宝搏网址首先出现在Tech At Bloomb188金宝搏怎么反水erg.



Chakri Cherukuri、Jason Grout、Kaia Young、Maarten Breddels、Romain Menegaux、Sylvain Corlay和Thomas Robitaille将在这一过渡期领导该项目。我们鼓励任何有兴趣帮助该项目定义其未来的人加入讨论。在未来几周内,该项目的存储库将托管一份治理文档草案,以便每个人都能提供反馈,过渡团队将定期发布更新和邀请参加本次讨论。


postbqplot现在是一个社区开源项目 首先出现在彭博资讯科技公司

行业协会如何促进彭博工程内部技术思想和最佳实践的交流 //www.gillanihygienic.com/blog/how-guilds-promote-the-exchange-of-technical-ideas-best-practices-within-bloomberg-engineering/ 彭博 周一4月13日2020 14:37:31 +0000 //www.gillanihygienic.com/blog/how-guilds-promote-the-exchange-of-technical-ideas-best-practices-within-bloomberg-engineering/





这在科技行业并不是一个新概念。2012年,Spotify首次推广了公会,敏捷工程团队利用公会来确定跨团队专家组="https://www.wired.com/2014/09/medieval-style-guilds-will-remake-tech-behind-facebook-google/“target=“\u blank”rel=“noopener noreferrer”>分享最佳实践。