• 谷歌访问助手不能激活

    William J. Bowman is an Assistant Professor of computer science in the Software Practices Lab at University of British Columbia. Broadly speaking, he is interested in making it easier for programmers to communicate their intent to machines, and preserving that intent through compilation. More specifically, his research interests include secure and verified compilation, dependently typed programming, verification, meta-programming, and interoperability. His recent work examines type-preserving compilation of dependently typed programming language like Coq, a technique that can enable preserving security and correctness invariants of verified software through compilation and statically enforcing those invariants in the low-level (assembly-like) code generated by compilers.

    谷歌访问助手不能激活

    • In Cyberspace:

      As a person or researcher:

          

      wjb

      As UBC faculty:

          

      wilbowma

    • In Space:

      ICICS/CS Building Room 389

      201 Main Mall

      Vancouver, BC V6T 1Z4 Canada

    • In Time: My Free/Busy Calendar

    谷歌访问助手不能激活

    • 免费Ⅴpn安卓 – PhD Track

      赶快卸载!这些APP上了工信部“黑名单”_新民社会_新民网 ...:2021-7-31 · 7月31日,工信部公布了2021年二季度检测发现问题的应用软件名单。 网络配图 7月31日,工信部公布了2021年二季度检测发现问题的应用软件名单。

    • Adam Geller – MSc.

      Working on typed Web Assembly for safety and performance.

      Co-advising with Ivan Beschastnikh.

    • Jonathan Chan – BS Honours Thesis

      Implementing sized types for Coq.

    谷歌访问助手不能激活

    谷歌访问助手不能激活

    Practical Sized Types for Coq.
    Jonathan Chan and William J. Bowman
    2019.
    Termination of recursive functions and productivity of corecursive functions are important for maintaining logical consistency in proof assistants. However, contemporary proof assistants, such as Coq, rely on syntactic criteria that prevent users from easily writing obviously terminating or productive programs, such as quicksort. This is troublesome, since there exist theories for type-based termination- and productivity-checking.

    In this paper, we present a design and implementation of sized type checking and inference for Coq. We extend past work on sized types for the Calculus of (Co)\-Inductive Constructions (CIC) with support for global definitions found in Gallina, and extend the sized-type inference algorithm to support completely unannotated Gallina terms. This allows our design to maintain complete backwards compatibility with existing Coq developments. We provide an implementation that extends the Coq kernel with optional support for sized types.
    AbstractAbstract (Hide) | arXiv | Artifact | GitHub

    2021最大最新最全的破解解密软件下载库 ...- 红豆博客 ...:2021-8-28 · 北京北软软件信息技术科技开发发展有限责任网络公司 电话:400-6868-340、86-10-51294342(共5 线) 电话:4006868340 010-51294342 传真:86-10-58850501-2620 邮箱:brrservice@vip.163.com 传真: 010-58850501 电话:400 6868 340 01051294342 ....
    William J. Bowman and Amal Ahmed
    2019.
    Programmers rely on dependently typed languages, such as Coq, to machine-verify high-assurance software, but get no guarantees after compiling or when linking after compilation. We could provide guarantees after compiling and linking by building type-preserving compilers, which preserve specifications encoded in types and use type checking to verify code after compilation and to ensure safety when linking with unverified code. Unfortunately, standard type-preserving translations do not scale to dependently typed languages for two key reasons: assumptions valid in simpler type systems no longer hold, and checking dependent types relies strongly on the syntax of programs, which compilers change.

    We extend the A-normal form (ANF) translation— a standard translation for making control flow explicit— to the Extended Calculus of Constructions (ECC), a representative subset of Coq. We prove type preservation, and prove correctness of separate compilation from ECC to an ANF-restricted ECC with a machine semantics. This is the first ANF translation for dependent types and, unlike related translations, supports the infinite universe hierarchy, and does so without relying on parametricity or impredicativity. Our work provides general insights into dependent-type-preservation and combining effects with dependent types.
    AbstractAbstract (Hide) | Proofs incomplete, but draft available on request.

    谷歌访问助手不能激活

    Dependent Type Systems as Macros.
    Stephen Chang, Michael Ballantyne, Milo Turner, William J. Bowman
    To appear In Popular VPN service to be shut down amid ongoing ...:2021-6-26 · A popular VPN service provider has announced it will stop services from July 1 following a regulation that bans telecommunication companies and Internet access providers from setting up or renting special lines, including VPNs, to carry out cross.
    We present Turnstile+, a high-level, macros-based metaDSL for building dependently typed languages. With it, programmers may rapidly prototype and iterate on the design of new dependently typed features and extensions. Or they may create entirely new DSLs whose dependent type “power” is tailored to a specific domain. Our framework’s support of language-oriented programming also makes it suitable for experimenting with systems of interacting components, e.g., a proof assistant and its companion DSLs. This paper explains the implementation details of Turnstile+, as well as how it may be used to create a wide-variety of dependently typed languages, from a lightweight one with indexed types, to a full spectrum proof assistant, complete with a tactic system and extensions for features like sized types and SMT interaction.AbstractAbstract (Hide) | Paper | Artifact | GitHub (Turnstile+) | GitHub (Cur)

    Typed Closure Conversion of the Calculus of Constructions.
    William J. Bowman and Amal Ahmed
    In List of Universities in China-China Youth International:List of Universities in China-China Youth International. Register on site Sign in..
    Dependently typed languages such as Coq are used to specify and verify the full functional correctness of source programs. Type-preserving compilation can be used to preserve these specifications and proofs of correctness through compilation into the generated target-language programs. Unfortunately, type-preserving compilation of dependent types is hard. In essence, the problem is that dependent type systems are designed around high-level compositional abstractions to decide type checking, but compilation interferes with the type-system rules for reasoning about run-time terms.

    We develop a type-preserving closure-conversion translation from the Calculus of Constructions (CC) with strong dependent pairs (Σ types)— a subset of the core language of Coq— to a type-safe, dependently typed compiler intermediate language named CC-CC. The central challenge in this work is how to translate the source type-system rules for reasoning about functions into target type-system rules for reasoning about closures. To justify these rules, we prove soundness of CC-CC by giving a model in CC. In addition to type preservation, we prove correctness of separate compilation.
    AbstractAbstract (Hide) | Paper | Technical Appendix | PLDI 2018 Talk (by me) | 安卓免费pn

    Type-Preserving CPS Translation of Σ and Π Types is Not Not Possible.
    William J. Bowman, Youyou Cong, Nick Rioux, and Amal Ahmed
    In Proc. of the Symposium on Principles of Programming Languages (POPL 2018)
    Dependently typed languages such as Coq are used to specify and prove functional correctness of source programs, but what we ultimately need are guarantees about correctness of compiled code. By preserving dependent types through each compiler pass, we could preserve source-level specifications and correctness proofs into the generated target-language programs. Unfortunately, type-preserving compilation of dependent types is a challenging problem. In 2002, Barthe and Uustalu showed that type-preserving CPS is \emph{not possible} for languages such as Coq. Specifically, they showed that for strong dependent pairs ($\Sigma$ types), the standard typed call-by-name CPS is \emph{not type preserving}. They further proved that for dependent case analysis on sums, a class of typed CPS translations— including the standard translation— is \emph{not possible}. In 2016, Morrisett noticed a similar problem with the standard call-by-value CPS translation for dependent functions ($\Pi$ types). In essence, the problem is that the standard typed CPS translation by double-negation, in which computations are assigned types of the form $(A \rightarrow \bot) \rightarrow \bot$, disrupts the term/type equivalence that is used during type checking in a dependently typed language.

    In this paper, we prove that type-preserving CPS translation for dependently typed languages is \emph{not} not possible. We develop both call-by-name and call-by-value CPS translations from the Calculus of Constructions with both $\Pi$ and $\Sigma$ types (CC) to a dependently typed target language, and prove type preservation and compiler correctness of each translation. Our target language is CC extended with an additional equivalence rule and an additional typing rule, which we prove consistent by giving a model in the extensional Calculus of Constructions. Our key observation is that we can use a CPS translation that employs \emph{answer-type polymorphism}, where CPS-translated computations have type $\forall \alpha. (A \rightarrow \alpha) \rightarrow \alpha$. This type justifies, by a \emph{free theorem}, the new equality rule in our target language and allows us to recover the term/type equivalences that CPS translation disrupts. Finally, we conjecture that our translation extends to dependent case analysis on sums, despite the impossibility result, and provide a proof sketch.
    AbstractⅤpn软件 | Paper | Technical Appendix | POPL 2018 Talk (by me) | 2021最大最新最全的破解解密软件下载库 ...- 红豆博客 ...:2021-8-28 · 北京北软软件信息技术科技开发发展有限责任网络公司 电话:400-6868-340、86-10-51294342(共5 线) 电话:4006868340 010-51294342 传真:86-10-58850501-2620 邮箱:brrservice@vip.163.com 传真: 010-58850501 电话:400 6868 340 01051294342 ... | Slides | Supplementary Materials

    原来Windows 10还有这么多隐藏的功能 - huanqiu.com:2021-10-5 · 8、免费去蓝光 夜晚使用电脑总会感觉很刺眼,于是便有小伙伴下载了各种去蓝光软件。其实Win10 本身就内置了一项去蓝光功能,效果不错,还能 ....
    Max New, William J. Bowman, and Amal Ahmed.
    In 中国青年手机应用下载_中国青年安卓版_中国青年IOS下载 ...:2021-6-13 · 中国青年是中国青年网官方出品的新闻及服务共青团组织资讯客户端,精心打造青闻天下、青年观察、学习者、漂在北上广等栏目,以青年之眼光,评析社会之现象;以青年之感悟,探索人生之真谛;以青年之视角,反映青年之心声。
    A fully abstract compiler guarantees that two source components are observationally equivalent in the source language if and only if their translations are observationally equivalent in the target. Full abstraction implies the translation is secure: target-language attackers can make no more observations of a compiled component than a source-language attacker interacting with the original source component. Proving full abstraction for realistic compilers is challenging because realistic target languages contain features (such as control effects) unavailable in the source, while proofs of full abstraction require showing that every target context to which a compiled component may be linked can be back-translated to a behaviorally equivalent source context.

    We prove the first full abstraction result for a translation whose target language contains exceptions, but the source does not. Our translation— specifically, closure conversion of simply typed λ-calculus with recursive types— uses types at the target level to ensure that a compiled component is never linked with attackers that have more distinguishing power than source-level attackers. We present a new back-translation technique based on a deep embedding of the target language into the source language at a dynamic type. Then boundaries are inserted that mediate terms between the untyped embedding and the strongly-typed source. This technique allows back-translating non-terminating programs, target features that are untypeable in the source, and well-bracketed effects.
    AbstractAbstract (Hide) | Paper | Technical Appendix | ICFP 2016 Talk (by Max New) | Author-Izer

    Noninterference for Free.
    William J. Bowman, and Amal Ahmed.
    In 中国のインターネット状況 -- pekinshuho:2021-12-2 · 中国政府は、合理的な手段を用いてインターネット上の違法な情報の伝播をくいとめることを主張する。インターネットの特性に基づき、効果的なインターネット管理の実際の需要から出発し、中国政府は関連の法律・法規に基づき、国際的な慣例にしたがうやり方を参考にしながら、技術的な ...
    Abadi et. al. (1999) introduced the dependency core calculus (DCC) as a framework for studying a variety of dependency analyses (e.g., secure information flow). The key property provided by DCC is noninterference, which guarantees that a low-level observer (attacker) cannot distinguish high-level (protected) computations. The proof of noninterference for DCC suggests a connection to parametricity in System F, which suggests that it should be possible to implement dependency analyses in languages with parametric polymorphism.

    In this paper, we present a translation from DCC into Fω and prove that the translation preserves noninterference. To express noninterference in Fω we define a notion of observer-sensitive equivalence that makes essential use of both first-order and higher-order polymorphism. Our translation provides insights into DCC’s type system and shows how DCC can be implemented in a polymorphic language without loss of the security/noninterference guarantees available in DCC. Our contributions include proof techniques that should be valuable when proving other secure compilation or full abstraction results.
    AbstractAbstract (Hide) | Paper | Technical Appendix | ICFP 2015 Talk (by me) | Slides | Author-Izer


    Profile-Guided Meta-Programming.
    William J. Bowman, Swaha Miller, Vincent St-Amour, and R. Kent Dybvig.
    In Proc. of the Conference on Programming Language Implementation and Design (PLDI 2015).
    Contemporary compiler systems such as GCC, .NET, and LLVM incorporate profile-guided optimizations (PGOs) on low-level intermediate code and basic blocks, with impressive results over purely static heuristics. Recent work shows that profile information is also useful for performing source-to-source optimizations via meta-programming. For example, using profiling information to inform decisions about data structures and algorithms can potentially lead to asymptotic improvements in performance.

    We present a design for profile-guided meta-programming in a general-purpose meta-programming system. Our design is parametric over the particular profiler and meta-programming system. We implement this design in two different meta-programming systems— the syntactic extensions systems of Chez Scheme and Racket— and provide several profile-guided meta-programs as usability case studies.
    免费下载∨PNAbstract (Hide) | Paper | Slides | 免费pn软件 | Author-Izer

    谷歌访问助手不能激活

    2021中国信息化和软件服务业年度风云榜榜单揭幕 - huanqiu.com:2021-1-19 · 以“释放原力、彰显价值”为主题的2021中国信息化和软件服务业年度风云榜网络评选活动正式落下帷幕。本次线上奖项评选活动由中国信息协会主办、信息化观察网、中国信息化网共同组织开展。
    William J. Bowman.
    Talk at the Workshop on Principles of Secure Compilation (PriSC 2018).
    Type-preserving compilation is used to statically enforce safety and security properties through type checking. The idea is to design strongly typed compiler target languages, preserve type information through the compiler, then use the types in the target language to enforce invariants when linking with untrusted code. Unfortunately, this technique is limited by the expressiveness of the target type system, and existing simple and polymorphic typed assembly languages cannot express all security invariants we wish to enforce. Dependent types could be used to express safety, security, and full functional correctness invariants. In this talk, I briefly describe work-in-progress on developing a dependently typed assembly, and how it could be used to statically enforce security guarantees when linking.AbstractAbstract (Hide) | Slides

    Only Control Effects and Dependent Types.
    Youyou Cong, William J. Bowman.
    Talk at the Workshop on Higher-order Programming with Effects (HOPE 2017).
    Abstract | GitHub

    免费pn软件.
    William J. Bowman.
    Talk at the Workshop on Higher-order Programming with Effects (HOPE 2016).
    Sophisticated domain-specific and user-defined notation is widely used in formal models, but is poorly supported by proof assistants. Many proof assistants support simple notation definitions, but no proof assistant enables users to conveniently define Ⅴpn软件 notation. For instance, in modeling a programming language, we often define infix relations such as Γ  e : t and use BNF notation to specify the syntax of the language. In a proof assistant like Coq or Agda, users can easily define the notation for Γ  e : t, but to use BNF notation the user must use a preprocessing tool external to the proof assistant, which is cumbersome.

    To support sophisticated user-defined notation, we propose to use language extension as a fundamental part of the design of a proof assistant. We describe how to design a language-extension systems that support safe, convenient, and sophisticated user-defined extensions, and how to design a proof assistant based on language extension. We evaluate this design by building a proof assistant that features a small dependent type theory as the core language and implementing the following extensions in small user-defined libraries: pattern matching for inductive types, dependently-typed staged meta-programming, a tactic-based proof language, and BNF and inference-rule notation for inductive type definitions.
    AbstractAbstract (Hide) | Draft Paper | HOPE 2016 Talk (by me) | GitHub

    Dagger Traced Symmetric Monoidal Categories and Reversible Programming.
    William J. Bowman, Roshan P. James, and Amr Sabry.
    In Proc. of the 4th Workshop on Reversible Computation (RC 2011).
    Paper | Code

    谷歌访问助手不能激活

    Cur: Designing a Less Devious Proof Assistant
    William J. Bowman
    Dijkstra said that our tools can have a profound and devious influence on our thinking. I find this especially true of modern proof assistants, with "devious" out-weighing "profound". Cur is an experiment in design that aims to be less devious. The design emphasizes language extension, syntax manipulation, and DSL construction and integration. This enables the user to be in charge of how they think, rather than requiring the user to contort their thinking to that of the proof assistant. In this talk, my goal is to convince you that you want similar capabilities in a proof assistant, and explain and demonstrate Cur’s attempt at solving the problem.AbstractAbstract (Hide) | Video | Slides (ODP) | Slides (Google Slides) | Demo Code | Cur GitHub

    Do Compilers Respect Programmers?
    William J. Bowman
    Video | Keynote | PDF

    谷歌访问助手不能激活

    99999999手史上最大买盘难挡石化权证归零 - huanqiu.com:2021-2-25 · 99999999手买单压在0.001元上豪赌,成为昨日(24日)石化CWB1谢幕表演中最疯狂的景象。石化CWB1(580019,收盘价0.001元)在昨日迎来行权前的最后一个交易日,由于行权基本无望,其开盘后便一路震荡走低,加速向价值回归。.
    William J. Bowman.
    POPL 2017 Student Research Competition
    Extended Abstract | Poster

    谷歌访问助手不能激活

    Compiling with Dependent Types.
    William J. Bowman.
    Northeastern University, Feb. 2019.
    Dependently typed languages have proven useful for developing large-scale fully verified software, but we do not have any guarantees after compiling that verified software. A verified program written in a dependently typed language, such as Coq, can be type checked to ensure that the program meets its specification. Similarly, type checking prevents us from importing a library and violating the specification declared by its types. Unfortunately, we cannot perform either of these checks after compiling a dependently typed program, since all current implementations erase types before compiling the program. Instead, we must trust the compiler to not introduce errors into the verified code, and, after compilation, trust the programmer to never introduce errors by linking two incompatible program components. As a result, the compiled and linked program is not verifiedwe have no guarantees about what it will do.

    In this dissertation, I develop a theory for preserving dependent types through compilation so that we can use type checking after compilation to check that no errors are introduced by the compiler or by linking. Type-preserving compilation is a well-known technique that has been used to design compilers for non-dependently typed languages, such as ML, that statically enforce safety and security guarantees in compiled code. But there are many open challenges in scaling type preservation to dependent types. The key problems are adapting syntactic type systems to interpret low-level representations of code, and breaking the complex mutually recursive structure of dependent type systems to make proving type preservation and compiler correctness feasible. In this dissertation, I explain the concepts required to scale type preservation to dependent types, present a proof architecture and language design that support type preservation, and prove type preservation and compiler correctness for four early-stage compiler translations of a realistic dependently typed calculus. These translations include an A-normal form (ANF), a continuation-passing style (CPS), an abstract closure conversion, and a parametric closure conversion translation.
    Abstract免费下载∨PN | PDF | Slides (keynote) | Slides (PDF)